lingo docs

import { generateText, Output, tool } from "ai" // ai@^6 or ai@^7
import {
  dateField,
  lingoObject,
  optional,
  quantityField,
  rangeField,
} from "@pascal-app/lingo/ai"

const schema = lingoObject({
  weight: quantityField({ kind: "mass", unit: "kg", min: 0, max: 500 }),
  height: quantityField({ kind: "length", unit: "m" }),
  deliverBy: dateField({ now }),
  boxWeight: rangeField({ kind: "mass", unit: "kg" }),
  tareWeight: optional(quantityField({ kind: "mass", unit: "kg", min: 0 })),
  carrier: "string",
})

const createShipment = tool({
  description: "Create a shipment record.",
  inputSchema: schema,
  execute: async (input) => warehouse.create(input),
})

const { output } = await generateText({
  model,
  tools: { createShipment },
  output: Output.object({ schema }),
  prompt: "Extract shipment details from this note.",
})
// output.weight is kg, deliverBy is ISO, tareWeight is number | null.
// AI SDK v5 needs the SDK's jsonSchema() wrapper around this schema.

import { generateText, tool } from "ai"
import {
  lingoObject,
  quantityField,
  repairToolCallWith,
} from "@pascal-app/lingo/ai"

const shipSchema = lingoObject({
  weight: quantityField({ kind: "mass", unit: "kg", min: 0 }),
})
const repairToolCall = repairToolCallWith({ ship: shipSchema })

await generateText({
  model,
  tools: {
    ship: tool({
      description: "Create a shipment.",
      inputSchema: shipSchema,
      execute: async ({ weight }) => ({ ok: true, kg: weight }),
    }),
  },
  prompt,
  experimental_repairToolCall: repairToolCall,
})
// experimental_repairText is the deprecated v5 generateObject path.

import {
  canonicalizeValues,
  dateField,
  quantityField,
  rangeField,
} from "@pascal-app/lingo/ai"

const repaired = canonicalizeValues(toolCall.args, {
  weight: quantityField({ kind: "mass", unit: "kg" }),
  height: quantityField({ kind: "length", unit: "m" }),
  deliverBy: dateField({ now }),
  boxWeight: rangeField({ kind: "mass", unit: "kg" }),
})

// severity: "error" blocked the path; warnings rode along on applied values.
const errors = repaired.issues.filter((issue) => issue.severity === "error")
if (errors.length > 0) {
  return { ok: false, issues: errors }
}

return createShipment(repaired.value)

import { dateField, quantityField } from "@pascal-app/lingo/ai"
import { lingoTool } from "@pascal-app/lingo/mcp"

const createShipment = lingoTool({
  name: "create_shipment",
  description: "Create a shipment; natural-language values welcome.",
  input: {
    weight: quantityField({ kind: "mass", unit: "kg", min: 0, max: 500 }),
    deliverBy: dateField({ min: "2026-01-01" }),
  },
  handler: ({ weight, deliverBy }) =>
    "Shipment logged: " + weight + " kg, deliver by " + deliverBy,
})

server.registerTool(createShipment.name, {
  description: createShipment.description,
  inputSchema: createShipment.inputSchema,
}, createShipment.callback)

import OpenAI from "openai"
import { dateField, lingoObject, quantityField, toJSONSchema } from "@pascal-app/lingo/ai"

const client = new OpenAI()
const schema = lingoObject({
  sku: "string",
  weight: quantityField({ kind: "mass", unit: "kg", min: 0 }),
  deliverBy: dateField({ now: new Date() }),
})

const completion = await client.chat.completions.create({
  model: "gpt-5.5",
  messages: [{ role: "user", content: "Ship SKU A100, 5 kg, tomorrow." }],
  tools: [{
    type: "function",
    function: {
      name: "create_shipment",
      description: "Create a shipment for one order line.",
      parameters: toJSONSchema(schema),
      strict: true,
    },
  }],
})

const call = completion.choices[0]?.message.tool_calls?.[0]
if (call?.type === "function" && call.function.name === "create_shipment") {
  const parsed = schema.safeParse(JSON.parse(call.function.arguments))
  if (!("value" in parsed)) return reportToolError(parsed.issues)
  await warehouse.create(parsed.value)
}

import Anthropic from "@anthropic-ai/sdk"
import { lingoObject, quantityField, toJSONSchema } from "@pascal-app/lingo/ai"

const schema = lingoObject({
  weight: quantityField({ kind: "mass", unit: "kg", min: 0, max: 1000 }),
  note: "string",
})

const toolDef: Anthropic.Tool = {
  name: "log_shipment",
  description: "Record a shipment weight and note.",
  input_schema: toJSONSchema(schema) as Anthropic.Tool.InputSchema,
  strict: true,
}

async function runTool(toolUse: Anthropic.ToolUseBlock): Promise<Anthropic.ToolResultBlockParam> {
  const parsed = schema.safeParse(toolUse.input)
  if ("issues" in parsed) {
    return {
      type: "tool_result",
      tool_use_id: toolUse.id,
      content: parsed.issues.map((issue) => issue.message).join("; "),
      is_error: true,
    }
  }
  await warehouse.log(parsed.value)
  return { type: "tool_result", tool_use_id: toolUse.id, content: "Logged." }
}

import { GoogleGenAI } from "@google/genai"
import { quantityField, toJSONSchema } from "@pascal-app/lingo/ai"

const weight = quantityField({ kind: "mass", unit: "kg", min: 0 })
const ai = new GoogleGenAI({})

await ai.models.generateContent({
  model: "gemini-2.5-flash",
  contents: "Ship 5 kg tomorrow.",
  config: {
    tools: [{
      functionDeclarations: [{
        name: "create_shipment",
        description: "Create a shipment record.",
        // Use parametersJsonSchema; never classic parameters/responseSchema.
        parametersJsonSchema: {
          type: "object",
          properties: { weight: toJSONSchema(weight) },
          required: ["weight"],
          additionalProperties: false,
        },
      }],
    }],
  },
})

import { ChatOpenAI } from "@langchain/openai"
import { createAgent, toolStrategy } from "langchain"
import { canonicalizeValues, lingoObject, quantityField } from "@pascal-app/lingo/ai"

const weight = quantityField({ kind: "mass", unit: "kg", min: 0 })
const schema = lingoObject({ weight })

const extract = new ChatOpenAI({ model: "gpt-4o-mini" }).withStructuredOutput(schema)
const result = await extract.invoke("about 40 lbs")
// result.weight is canonical kg when the model override validates Standard Schema.

const agent = createAgent({
  model: "gpt-4o-mini",
  tools: [],
  responseFormat: toolStrategy(schema, { handleError: true }),
})
const { structuredResponse } = await agent.invoke({ messages })
// createAgent + toolStrategy validate shape only; canonicalize values yourself.
const { value, issues } = canonicalizeValues(structuredResponse, { weight })

import { lingoInput } from "@pascal-app/lingo/dom"

const input = document.querySelector<HTMLInputElement>("#height")!
const field = lingoInput(input, {
  kind: "length",
  unit: "m",
  name: "height_m",
})

// Verified on the docs form: 5'11" commits hidden height_m=1.8034.
field.set("5'11\"")
field.commit()

field.value // 1.8034
new FormData(input.form!).get("height_m") // "1.8034"