// Create a tool with a discriminatedUnion and positive

/*
expiration: z
        // will cause 400
        .discriminatedUnion("type", [
          z.object({
            type: z.literal("relative"),
            relativeSeconds: z
              .number()
              // Will cause 400
              .positive()
              .describe("Number of seconds from now until expiration"),
          }),
          z.object({
            type: z.literal("exact"),
            exactDate: z
              .string()
              .describe(
                "Exact expiration date/time in ISO 8601 format (e.g., '2025-06-01T00:00:00Z')",
              ),
          }),
        ])

*/



import { ChatVertexAI } from "@langchain/google-vertexai";
export const geminiPro = new ChatVertexAI({
  model: "gemini-2.5-pro",
  temperature: 0.3,
  maxConcurrency: 50,
  maxRetries: 20,
  location: "global",
  platformType: "gcp",
  cache: true,
  vertexai: true,
});


// ...
const toolNode = new ToolNode(aggregatedTools);
const modelWithTools = llm.bindTools(aggregatedTools);

  async function callModel(state: typeof LiteState.State) {
    const messages = [...state.messages];

    const chain = prompt.pipe(modelWithTools);
    const response = await chain.invoke(
      {
        ...state,
        messages,
      },
      { maxConcurrency: 50 },
    );

    return response;
  }

  const liteAgentNodeName = "lite_agent";
  const workflow = new StateGraph(LiteState)
    .addNode(liteAgentNodeName, callModel)
    .addEdge("__start__", liteAgentNodeName)
    .addNode("tools", toolNode)
    .addEdge("tools", liteAgentNodeName)
    .addConditionalEdges(liteAgentNodeName, shouldContinue);

  const compiledLiteGraph = workflow.compile({ store: liteStore });

  const result = await compiledLiteGraph.invoke(
    {
      messages: [
        ...state.messages,
      ],
    },
    {
      ...config,
      maxConcurrency: 50,
    },
  );