Generating an Artifact in a Conversation

import { z } from "zod";
import { zodToJsonSchema } from "zod-to-json-schema";

const createPresentationTool = {
  type: "function",
  function: {
    name: "create_presentation",
    description: "Creates a slide presentation based on a topic.",
    parameters: zodToJsonSchema(
      z.object({
        instructions: z.string().describe("The instructions to generate the presentation."),
      })
    ),
  },
};

from pydantic import BaseModel, Field

class CreatePresentationParams(BaseModel):
    instructions: str = Field(..., description="The instructions to generate the presentation.")

create_presentation_tool = {
    "type": "function",
    "function": {
        "name": "create_presentation",
        "description": "Creates a slide presentation based on a instructions.",
        "parameters": CreatePresentationParams.model_json_schema(),
    },
}

// (Inside your Next.js API route)
import { nanoid } from "nanoid";
import { makeC1Response } from "@thesysai/genui-sdk/server";

// When your tool handler is invoked by the LLM...
async function handleCreatePresentation(
  // following parameters are passed by the LLM
  { instructions }: { instructions: string },
  // following parameters are passed by your backend
  { messageId, c1Response }: { messageId: string, c1Response: ReturnType<typeof makeC1Response> }
) {
  // 2. Call the Artifacts API and stream the result.
  const artifactStream = await c1ArtifactsClient.chat.completions.create({
    model: "c1/artifact/v-20251030",
    messages: [{ role: "user", content: instructions }],
    metadata: { thesys: JSON.stringify({ c1_artifact_type: "slides", id: artifactId }) },
    stream: true,
  });

    // 3. Pipe the artifact stream into the C1 Response object.
    for await (const delta of artifactStream) {
      const content = delta.choices[0]?.delta?.content;
      if (content) {
        c1Response.writeContent(content);
      }
    }

    // 4. Return the result to the main LLM so it knows the tool succeeded.
    return `Presentation created with artifact_id: ${artifactId}, version: ${messageId}`,
}
// After the tool result is sent, the main LLM will generate its final text response.
// You will then pipe that final text stream into the same `c1Response` object
// before returning `c1Response.responseStream` from your API route.

# (Inside your FastAPI route)
import nanoid
from thesys_genui_sdk.fast_api import with_c1_response
from thesys_genui_sdk.context import write_content

# for more details on how to use thesys_genui_sdk, see https://pypi.org/project/thesys-genui-sdk/.

# When your tool handler is invoked by the LLM...
async def handle_create_presentation(instructions: str, message_id: str):
    # 1. Developer generates unique IDs.
    artifact_id = nanoid.generate(size=10)
    message_id = nanoid.generate(size=10) # This will serve as the first version.

    # 2. Call the Artifacts API and stream the result.
    artifact_stream = await c1_artifacts_client.chat.completions.create(
        model="c1/artifact/v-20251030",
        messages=[{"role": "user", "content": f"Create a presentation about {topic}"}],
        metadata={"thesys": json.dumps({"c1_artifact_type": "slides", "id": artifact_id})},
        stream=True,
    )

    # 3. Pipe the artifact stream using the write_content helper.
    async for delta in artifact_stream:
        content = delta.choices[0].delta.content
        if content:
            await write_content(content)

    # 4. Return the result to the main LLM.
    return f"Presentation created with artifact_id: {artifact_id}, version: {message_id}"
# Your main logic will then take this tool result, send it back to the LLM,
# and stream the final text confirmation using the same `write_content` helper.