TomTom Maps for JavaScript
    Preparing search index...

    Type Alias MapAgentOptions<CS>

    Options for creating an agent toolkit.

    interface MyState extends ToolState {
        fleet: FleetState;
    }

    createMapAgent<MyState>(map, {
        model,
        state: { fleet: new FleetState() },
    });
    type MapAgentOptions<CS extends ToolState = ToolState> = {
        classifier?: Classifier | false;
        dataEntries?: Partial<Record<DataEntryKind, DataEntryConfig>>;
        featureFlags?: FeatureFlags;
        includeDefaultTools?: boolean;
        maxSteps?: number;
        model: LanguageModel;
        onClassify?: (result: ClassificationResult | null) => void;
        outputSchemas?: boolean;
        prepareStep?: PrepareStepFunction;
        providerOptions?: ProviderOptions;
        state?: Omit<CS, keyof ToolState>;
        stepProviderOptions?: (
            info: { activeTools: string[] | undefined; stepNumber: number },
        ) => ProviderOptions | undefined;
        systemPrompt?: string;
        systemPromptSuffix?: string;
        tools?: { [K in ToolNameHint]?: ToolEntry<CS> | false };
    }

    Type Parameters

    • CS extends ToolState = ToolState

      Full state type. Must extend ToolState. Defaults to base ToolState (no custom slices).

    Index

    Properties

    classifier? dataEntries? featureFlags? includeDefaultTools? maxSteps? model onClassify? outputSchemas? prepareStep? providerOptions? state? stepProviderOptions? systemPrompt? systemPromptSuffix? tools?

    Properties

    classifier?: Classifier | false

    Pluggable classifier for automatic tool selection.

    • Omit to use the default LLM-based classifier (uses main model)
    • Pass a Classifier function for custom logic
    • Pass false to disable classification entirely
    dataEntries?: Partial<Record<DataEntryKind, DataEntryConfig>>

    Per-kind data-entry configuration. Each DataEntryKind accepts { enabled?, entryMode? }. Setting enabled: false removes the kind from the agent's tool surface entirely — it disappears from analyseData / processData scope and input fields, and the slice-specific recall / display / fetch tools are dropped from the registry. entryMode is applied to the underlying slice right after the agent state is built — before any tool runs.

    Keys are LLM-facing kind names (routes, incidents) — not slice names (routing, trafficIncidents). The slice mapping is internal.

    createMapAgent(map, {
        model: openai('gpt-4o'),
        dataEntries: {
            routes: { entryMode: 'single' },
            incidents: { entryMode: 'single' },
            byod: { enabled: false }, // disables recallByod, addByodLayer, updateByodDisplay + byod scope on analyse/process
            ranges: { enabled: false }, // disables findReachableAreas + recallRanges
        },
    });
    featureFlags?: FeatureFlags

    Opt into in-flight or experimental agent-toolkit behaviour. Stability varies per flag — see FeatureFlags and each flag's own doc.

    includeDefaultTools?: boolean

    Whether to include all built-in default tools. Defaults to true. Set to false to start with no defaults and provide only custom tools via tools.

    maxSteps?: number

    Max multi-step tool loop iterations. Default: 10.

    model: LanguageModel

    AI SDK language model instance. REQUIRED — no default provider.

    onClassify?: (result: ClassificationResult | null) => void

    Called after each classification. Use to observe selected tools or log.

    outputSchemas?: boolean

    Whether to include output schemas on tools. Defaults to true. Set to false for providers that don't support structured tool outputs.

    prepareStep?: PrepareStepFunction

    Custom prepareStep hook, composed with internal classification step. Your activeTools are intersected with the classifier's selection.

    providerOptions?: ProviderOptions

    Provider-specific options forwarded to the AI SDK on every step. Keyed by provider id (openai, azure, anthropic, ...).

    Use this to enable reasoning summaries for gpt-5.x via the Responses API — without reasoningSummary the model thinks but returns no reasoning text:

    createMapAgent(map, {
        model: azure.responses(deploymentId),
        providerOptions: {
            openai: { reasoningEffort: 'low', reasoningSummary: 'auto' },
        },
    });
    state?: Omit<CS, keyof ToolState>

    Custom state slices merged alongside built-in state. Only custom slices need to be provided — built-in slices are created automatically. Accessible in custom tool execute via the state parameter.

    stepProviderOptions?: (
        info: { activeTools: string[] | undefined; stepNumber: number },
    ) => ProviderOptions | undefined

    Per-step providerOptions override. Called once per step with the classifier-narrowed active toolset; the returned object is merged on top of providerOptions for that step. Use it to bump reasoning effort on turns that include a code-execution tool without paying the cost on simple fetch/toggle turns.

    stepProviderOptions: ({ activeTools }) =>
        activeTools?.some((t) => CODE_EXEC.has(t))
            ? { openai: { reasoningEffort: 'medium' } }
            : undefined,
    systemPrompt?: string

    Complete system prompt that replaces the default. If provided, systemPromptSuffix is ignored.

    systemPromptSuffix?: string

    Additional text appended to the built-in prompt. Ignored if systemPrompt is provided.

    tools?: { [K in ToolNameHint]?: ToolEntry<CS> | false }

    Tool overrides merged with default tools.

    • ToolEntry values add a new tool or replace a default.
    • false values exclude a default tool.

    When omitted, all default tools are used as-is.

    // Add a custom tool (defaults included automatically)
    createMapAgent(map, {
        model,
        tools: { getCustomLocation: myTool },
    });

    // Remove a default tool
    createMapAgent(map, {
        model,
        tools: { setLanguage: false },
    });

    Settings

    Member Visibility

    On This Page

    Properties