AI sessions and actions

{
  "tools": [
    {
      "id": "cad",
      "description": "Read the open drawing. All actions are read-only.\n\nActions\n- describe: the drawing: counts, bounds and layers. Start here.\n- check: model checks (sizes, rotations, Boolean operands, duplicates, floating parts); fix findings after modelling.\n- relations: bounds, placement, distances and parameter dependencies; equal names do not bind parameters.\n- grep: search ids, names, layers and properties; includes each parametric hit's revision.\n- vision: the CAD viewport plus scene evidence as an image.\n- inspect_elements: full properties and bounds of elements, paged.\n- inspect_layers: the workspace layers and the active one.\n- inspect_search: elements whose text matches a query, paged.\n- inspect_property: one property of one element by path, paged by characters.\n- parametric_validate: rebuild a parametric history and report what it cannot build.\n- parametric_inspect: history, parameters and report of one parametric part.\n- drawing: technical sheet from one elementId or history; options (sheet, projection, views, section, detail: see schema). SVG, dimensions, callouts, warnings; exact B-rep edges where available; nothing stored.\n- parametric_test: run parameter variants; report bodies, volumes and dimensional checks.\n- parametric_dfm: manufacturability findings for a history or an existing part.\n- parametric_exact: exact B-rep per body (volume, area, centroid, throughHoles, faces, surfaces) or why mesh-only; STEP on request.\n- exact: every solid on the exact kernel: validity, volume, bounds, holes, and whether CAM machines it by features or as a 3D surface, with why.\n- assembly: exact interference (clash volumes), bill of materials with mass, hole joints, fasteners still missing.\n- parametric_fastener: thread, tap drill, clearance and counterbore of a metric size.\n- parametric_recipe: standard part history from `recipe` (mounting_plate, flange, l_bracket, stepped_shaft, pipe_bend, duct_transition, enclosure) and `params`; cad_edit.parametric_recipe_create stores it.\n- parametric_from_element: history with named parameters from an existing solid, flat shape or component; cad_edit.parametric_convert stores it.\n\nParameters (mm, radians; ids are read, never invented)\n- describe, check, inspect_layers: none.\n- relations: firstId, secondId - two different existing ids.\n- grep: query (1-200 chars), layerId, parametricOnly, includeParameters, offset, limit (1-50).\n- vision: focus - wha
…

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// no input
const result = await client.ai.actions()

curl --request GET "${CADCAMFUN_URL}/api/ai/actions" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiInvokeActionInput
const result = await client.ai.invokeAction({
  projectId: "",
  drawingId: "",
  callId: "",
  tool: "",
  input: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/actions/invoke" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiIssueBridgeTokenInput
const result = await client.ai.issueBridgeToken({
  name: "",
  projectId: "",
  mode: "read",
  days: 0
})

curl --request POST "${CADCAMFUN_URL}/api/ai/bridge/tokens" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

[]

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// no input
const result = await client.ai.bridgeTokens()

curl --request GET "${CADCAMFUN_URL}/api/ai/bridge/tokens" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiRevokeBridgeTokenInput
const result = await client.ai.revokeBridgeToken({
  id: "<id>"
})

curl --request DELETE "${CADCAMFUN_URL}/api/ai/bridge/tokens/<id>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

[
  {
    "id": "general",
    "title": "General",
    "description": "Does drawing and machining itself, and delegates separable work to subagents (background tasks included).",
    "tools": [],
    "edits": true
  },
  {
    "id": "cad",
    "title": "CAD",
    "description": "Drawing and 3D modelling. Reads the machining side but does not change operations, G-code or the machining libraries.",
    "tools": [],
    "edits": true
  },
  {
    "id": "cam",
    "title": "CAM",
    "description": "Machining: operations, G-code, verification and the machining libraries. Reads the drawing but does not change it.",
    "tools": [],
    "edits": true
  }
]

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// no input
const result = await client.ai.agents()

curl --request GET "${CADCAMFUN_URL}/api/ai/agents" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiSessionControlInput
const result = await client.ai.sessionControl({
  sessionId: "",
  projectId: "",
  action: "status",
  criteria: null,
  taskId: "",
  requestId: "",
  answers: [
    [
      ""
    ]
  ],
  decision: "once",
  model: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/sessions/control" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiSessionStateInput
const result = await client.ai.sessionState({
  sessionId: "",
  projectId: ""
})

curl --request POST "${CADCAMFUN_URL}/api/ai/sessions/state" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiRemoveSessionInput
const result = await client.ai.removeSession({
  sessionId: "",
  projectId: ""
})

curl --request POST "${CADCAMFUN_URL}/api/ai/sessions/remove" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/sessions/prompt`, {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request POST "${CADCAMFUN_URL}/api/ai/sessions/prompt" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/sessions/${sessionId}/stream`, {
  method: "GET",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request GET "${CADCAMFUN_URL}/api/ai/sessions/<sessionId>/stream" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/sessions`, {
  method: "GET",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request GET "${CADCAMFUN_URL}/api/ai/sessions?projectId=<projectId>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/sessions/${sessionId}/messages`, {
  method: "GET",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request GET "${CADCAMFUN_URL}/api/ai/sessions/<sessionId>/messages" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/mcp`, {
  method: "GET",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request GET "${CADCAMFUN_URL}/api/ai/extensions/mcp?projectId=<projectId>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/mcp`, {
  method: "PUT",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request PUT "${CADCAMFUN_URL}/api/ai/extensions/mcp" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/mcp/${name}`, {
  method: "DELETE",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request DELETE "${CADCAMFUN_URL}/api/ai/extensions/mcp/<name>?projectId=<projectId>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/plugins/${id}`, {
  method: "DELETE",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request DELETE "${CADCAMFUN_URL}/api/ai/extensions/plugins/<id>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/plugins/${id}`, {
  method: "PUT",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request PUT "${CADCAMFUN_URL}/api/ai/extensions/plugins/<id>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/plugins`, {
  method: "GET",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request GET "${CADCAMFUN_URL}/api/ai/extensions/plugins" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/plugins`, {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request POST "${CADCAMFUN_URL}/api/ai/extensions/plugins" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/mods`, {
  method: "GET",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request GET "${CADCAMFUN_URL}/api/ai/extensions/mods" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/mods/${id}`, {
  method: "PUT",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request PUT "${CADCAMFUN_URL}/api/ai/extensions/mods/<id>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/extensions/mods/${id}`, {
  method: "DELETE",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request DELETE "${CADCAMFUN_URL}/api/ai/extensions/mods/<id>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/modes`, {
  method: "GET",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request GET "${CADCAMFUN_URL}/api/ai/modes" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

{
  "skills": [
    {
      "name": "cad-3d-modeling",
      "description": "Model 3D and 2D geometry in the open editor (45 element types): conventions, recipes for common parts, how to build complex objects.",
      "builtIn": true,
      "category": "cad"
    },
    {
      "name": "cam-operation-workflow",
      "description": "The loop from a drawing to verified G-code: describe, parameters, operation, generate, analyse, verify, fix.",
      "builtIn": true,
      "category": "cam"
    },
    {
      "name": "toolpath-verification",
      "description": "How to read and report a cam_edit action verify result: every finding code, its cause and its fix, and what was not modelled.",
      "builtIn": true,
      "category": "cam"
    },
    {
      "name": "cutting-parameters",
      "description": "Speeds, feeds, stepdown and stepover starting points by material, and the formulas behind them.",
      "builtIn": true,
      "category": "cam"
    },
    {
      "name": "drilling-and-holes",
      "description": "Drilling operations: cycles, peck rules, through-hole depth, large holes.",
      "builtIn": true,
      "category": "cam"
    },
    {
      "name": "precision-and-tolerances",
      "description": "Working to microns: nominal sizes, tolerance on round shapes, ISO 286 grades, finishing strategy and what the verification can and cannot show.",
      "builtIn": true,
      "category": "cam"
    },
    {
      "name": "industrial-standards",
      "description": "Mechanical and industrial rules for professional parts: ISO 2768 general tolerances, ISO 286 fits, surface finish, ISO 273 / ISO 4762 fastener holes, tap drills, DIN 6885 keys, ISO 54 gears, preferred numbers, design rules per process (milling, turning, sheet metal, casting, printing) and material densities.",
      "builtIn": true,
      "category": "cad"
    },
    {
      "name": "machines-and-axes",
      "description": "Mill, lathe and 3D printer: what turns, the sense of every axis, zeros and work offsets, touch probes and tool setters, and how to check a program against its machine.",
      "builtIn": true,
      "category": "cam"
    },
    {
      "name": "drawings-and-images",
      "description": "From a DXF/SVG file, an image of a dimensioned drawing, a photo or a sketch to a 3D model: which tool, what to ask, how to check the result.",
      "builtIn": true,
      "category": "cad"
    },
    {
      "name": "plugin-authoring",
      "description": "Write an extension for the ap
…

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// no input
const result = await client.ai.skills()

curl --request GET "${CADCAMFUN_URL}/api/ai/skills" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiSaveSkillInput
const result = await client.ai.saveSkill({
  markdown: "",
  name: "",
  description: "",
  body: ""
})

curl --request PUT "${CADCAMFUN_URL}/api/ai/skills" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiDeleteSkillInput
const result = await client.ai.deleteSkill({
  name: "<name>"
})

curl --request DELETE "${CADCAMFUN_URL}/api/ai/skills/<name>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiSetCredentialsInput
const result = await client.ai.setCredentials({
  provider: "",
  key: "",
  baseUrl: ""
})

curl --request PUT "${CADCAMFUN_URL}/api/ai/credentials" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiClearCredentialsInput
const result = await client.ai.clearCredentials({
  provider: "<provider>"
})

curl --request DELETE "${CADCAMFUN_URL}/api/ai/credentials/<provider>" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

{
  "providers": {
    "anthropic": "missing",
    "openai": "missing",
    "minimax": "missing",
    "gateway": "missing"
  },
  "configured": false,
  "host": "direct"
}

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// no input
const result = await client.ai.status()

curl --request GET "${CADCAMFUN_URL}/api/ai/status" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

[
  {
    "id": "claude-haiku-4-5",
    "provider": "anthropic",
    "tier": "fast",
    "contextWindow": 200000,
    "tools": true,
    "vision": true,
    "configured": false
  },
  {
    "id": "claude-sonnet-5-5",
    "provider": "anthropic",
    "tier": "balanced",
    "contextWindow": 1000000,
    "tools": true,
    "vision": true,
    "configured": false
  },
  {
    "id": "claude-opus-5-5",
    "provider": "anthropic",
    "tier": "best",
    "contextWindow": 1000000,
    "tools": true,
    "vision": true,
    "configured": false
  },
  {
    "id": "gpt-5-mini",
    "provider": "openai",
    "tier": "fast",
    "contextWindow": 400000,
    "tools": true,
    "vision": true,
    "configured": false
  },
  {
    "id": "gpt-5",
    "provider": "openai",
    "tier": "balanced",
    "contextWindow": 400000,
    "tools": true,
    "vision": true,
    "configured": false
  },
  {
    "id": "MiniMax-M2",
    "provider": "minimax",
    "tier": "fast",
    "contextWindow": 200000,
    "tools": true,
    "vision": false,
    "configured": false
  },
  {
    "id": "anthropic/claude-haiku-4-5",
    "provider": "gateway",
    "tier": "fast",
    "contextWindow": 200000,
    "tools": true,
    "vision": true,
    "configured": false
  },
  {
    "id": "anthropic/claude-sonnet-5-5",
    "provider": "gateway",
    "tier": "balanced",
    "contextWindow": 1000000,
    "tools": true,
    "vision": true,
    "configured": false
  },
  {
    "id": "anthropic/claude-opus-5-5",
    "provider": "gateway",
    "tier": "best",
    "contextWindow": 1000000,
    "tools": true,
    "vision": true,
    "configured": false
  }
]

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiModelsInput
const result = await client.ai.models({})

curl --request GET "${CADCAMFUN_URL}/api/ai/models" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/models/refresh`, {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request POST "${CADCAMFUN_URL}/api/ai/models/refresh" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

[
  {
    "id": "anthropic",
    "name": "anthropic",
    "source": "config",
    "auth": [
      "api"
    ],
    "configured": false,
    "models": [
      {
        "id": "claude-haiku-4-5",
        "name": "claude-haiku-4-5",
        "provider": "anthropic",
        "contextWindow": 200000,
        "maxOutput": 16000,
        "reasoning": false,
        "variants": [],
        "tools": true,
        "vision": true,
        "cost": {
          "input": 0,
          "output": 0
        }
      },
      {
        "id": "claude-sonnet-5-5",
        "name": "claude-sonnet-5-5",
        "provider": "anthropic",
        "contextWindow": 1000000,
        "maxOutput": 16000,
        "reasoning": false,
        "variants": [],
        "tools": true,
        "vision": true,
        "cost": {
          "input": 0,
          "output": 0
        }
      },
      {
        "id": "claude-opus-5-5",
        "name": "claude-opus-5-5",
        "provider": "anthropic",
        "contextWindow": 1000000,
        "maxOutput": 16000,
        "reasoning": false,
        "variants": [],
        "tools": true,
        "vision": true,
        "cost": {
          "input": 0,
          "output": 0
        }
      }
    ]
  },
  {
    "id": "openai",
    "name": "openai",
    "source": "config",
    "auth": [
      "api"
    ],
    "configured": false,
    "models": [
      {
        "id": "gpt-5-mini",
        "name": "gpt-5-mini",
        "provider": "openai",
        "contextWindow": 400000,
        "maxOutput": 16000,
        "reasoning": false,
        "variants": [],
        "tools": true,
        "vision": true,
        "cost": {
          "input": 0,
          "output": 0
        }
      },
      {
        "id": "gpt-5",
        "name": "gpt-5",
        "provider": "openai",
        "contextWindow": 400000,
        "maxOutput": 16000,
        "reasoning": false,
        "variants": [],
        "tools": true,
        "vision": true,
        "cost": {
          "input": 0,
          "output": 0
        }
      }
    ]
  },
  {
    "id": "minimax",
    "name": "minimax",
    "source": "config",
    "auth": [
      "api"
    ],
    "configured": false,
    "models": [
      {
        "id": "MiniMax-M2",
        "name": "MiniMax-M2",
        "provider": "minimax",
        "contextWindow": 200000,
        "maxOutput": 16000,
        "reasoning": false,
        "variants": [],
        "tools": true,
        "vision": false,
        "cost": {
          "input": 0,
          "output"
…

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// no input
const result = await client.ai.providers()

curl --request GET "${CADCAMFUN_URL}/api/ai/providers" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

{
  "prompts": [
    "How do I get started with CAD/CAM?",
    "What's the difference between CAD and CAM?",
    "Can you recommend resources for learning more?"
  ]
}

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiPromptsInput
const result = await client.ai.prompts({})

curl --request GET "${CADCAMFUN_URL}/api/ai/prompts" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}"

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiTitleInput
const result = await client.ai.title({
  excerpt: "",
  model: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/title" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiDesignAnalysisInput
const result = await client.ai.designAnalysis({
  description: "",
  layer: "",
  machine: "",
  model: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/design-analysis" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiMachiningParametersInput
const result = await client.ai.machiningParameters({
  material: "",
  tool: "",
  operation: "",
  machine: "",
  model: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/machining-parameters" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiGcodeOptimizationInput
const result = await client.ai.gcodeOptimization({
  gcode: "",
  material: "",
  machineType: "",
  constraints: "",
  model: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/gcode-optimization" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiDesignSuggestionsInput
const result = await client.ai.designSuggestions({
  elements: "",
  currentOperation: "",
  currentTool: "",
  model: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/design-suggestions" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiChatInput
const result = await client.ai.chat({
  messages: null,
  mcpServerId: "",
  mcpReference: ""
})

curl --request POST "${CADCAMFUN_URL}/api/ai/chat" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiChatStreamInput
const result = await client.ai.chatStream({
  permissionMode: "auto",
  agent: "",
  mode: "",
  attachments: [
    {
      name: "",
      data: ""
    }
  ],
  message: "",
  sessionId: "",
  projectId: "",
  drawingId: "",
  context: "",
  includeContext: false,
  model: {}
})

curl --request POST "${CADCAMFUN_URL}/api/ai/chat/stream" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiChatQueueInput
const result = await client.ai.chatQueue({
  sessionId: "",
  message: "",
  projectId: "",
  delivery: "queue"
})

curl --request POST "${CADCAMFUN_URL}/api/ai/chat/queue" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiChatAbortInput
const result = await client.ai.chatAbort({
  sessionId: "",
  projectId: ""
})

curl --request POST "${CADCAMFUN_URL}/api/ai/chat/abort" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiPermissionReplyInput
const result = await client.ai.permissionReply({
  sessionId: "",
  projectId: "",
  requestId: "",
  decision: "once"
})

curl --request POST "${CADCAMFUN_URL}/api/ai/permission/reply" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiCompletionInput
const result = await client.ai.completion({
  prompt: "",
  systemPrompt: "",
  model: "",
  temperature: 0
})

curl --request POST "${CADCAMFUN_URL}/api/ai/completion" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiAnalyzeGcodeInput
const result = await client.ai.analyzeGcode({
  gcode: "",
  model: ""
})

curl --request POST "${CADCAMFUN_URL}/api/ai/analyze-gcode" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiGcodeInput
const result = await client.ai.gcode({
  action: "",
  gcode: "",
  partialCode: "",
  machineType: "",
  material: "",
  model: "",
  options: null,
  description: "",
  toolpathType: ""
})

curl --request POST "${CADCAMFUN_URL}/api/ai/gcode" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiToolpathAnalysisInput
const result = await client.ai.toolpathAnalysis({
  gcode: "",
  model: "",
  max_tokens: 0
})

curl --request POST "${CADCAMFUN_URL}/api/ai/toolpath-analysis" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiFeedbackInput
const result = await client.ai.feedback({
  messageId: "",
  rating: "",
  comment: ""
})

curl --request POST "${CADCAMFUN_URL}/api/ai/feedback" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

import { CadCam } from "@cadcamfun/api/sdk"

const client = CadCam.make({
  baseUrl: process.env.CADCAMFUN_URL!,
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

// AiProxyInput
const result = await client.ai.proxy({
  model: "",
  messages: null,
  max_tokens: 0,
  temperature: 0,
  system: null,
  reasoning: null
})

curl --request POST "${CADCAMFUN_URL}/api/ai/proxy" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/oauth/authorize`, {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request POST "${CADCAMFUN_URL}/api/ai/oauth/authorize" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json

// Not generated in the Promise SDK (multipart, binary or raw body): call it with fetch.
const response = await fetch(`${process.env.CADCAMFUN_URL}/api/ai/oauth/complete`, {
  method: "POST",
  headers: { authorization: `Bearer ${process.env.CADCAMFUN_TOKEN}` },
})

curl --request POST "${CADCAMFUN_URL}/api/ai/oauth/complete" \
  --header "Authorization: Bearer ${CADCAMFUN_TOKEN}" \
  --header "Content-Type: application/json" \
  --data-binary @request.json