@collective-intelligence/extensions-sdk 0.2.9 → 0.2.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -407,8 +407,7 @@ declaration. Manifest parsing refuses the kinds `knowledgeRelationSchema` and
407
407
  Reference Field (`fieldSemantics["/<key>"].relation`) instead. Manifest parsing
408
408
  also names each retired key: `relationSchemaCapabilities` of a connector,
409
409
  `relationBindings` of a connector instance, `relationSchemaFqns` of a domain
410
- template, `knowledge.relationSchemas` of a tool binding, and the pipeline task
411
- kind `relation`. Stored releases read with
410
+ template, and the pipeline task kind `relation`. Stored releases read with
412
411
  `parseStoredExtensionReleaseManifest` drop only the components of a retired
413
412
  kind, the retired keys, `relation` pipeline tasks and each step or pipeline
414
413
  left without a task; `withCurrentPrimitive` reads one stored primitive
@@ -799,7 +798,11 @@ declareAgent({
799
798
  ### Tool binding controls
800
799
 
801
800
  A `tools` entry of an Agent or a Skill may be a `ToolBinding` instead of a bare
802
- reference. Both helpers accept and normalize the same shape:
801
+ reference. Both helpers accept and normalize the same shape, for every tool,
802
+ built-in or custom. A binding has two layers: host controls that are the same
803
+ for every tool (`tool`, `name`, `description`, `approval`), and one `settings`
804
+ object that the tool's binding settings form defines. A binding has no
805
+ tool-specific property.
803
806
 
804
807
  ```ts
805
808
  declareSkill({
@@ -810,10 +813,10 @@ declareSkill({
810
813
  {
811
814
  tool: "builtin.core.knowledge.tools.query",
812
815
  name: "member-query", // optional; bind one tool several times by name
813
- settings: { limit: 10 }, // checked against the tool's binding form
814
- knowledge: {
815
- domains: { include: [membersDomain] },
816
- entitySchemas: { exclude: ["com.acme.schemas.contact"] }
816
+ description: "Search the member companies", // optional; for the model
817
+ settings: {
818
+ // The tool's form marks this field `"x-fqn-of": "knowledge-domain"`.
819
+ allowedDomainIds: ["com.acme.domains.members"]
817
820
  },
818
821
  approval: { rule: "Escalations" } // or "never" | "always"
819
822
  }
@@ -823,18 +826,72 @@ declareSkill({
823
826
  })
824
827
  ```
825
828
 
826
- - `knowledge` selectors take handles of their own kind (`domain`,
827
- `knowledgeEntitySchema`) or FQN strings. Install
828
- resolves them to the Organization's definitions and rejects an unknown one,
829
- or a `knowledge` boundary on a tool that has no Knowledge scope.
829
+ - `settings` is checked at install against the tool's binding settings form
830
+ and keeps the form's field keys. A field that the form marks with
831
+ `x-fqn-of` (see [JSON value boundaries](#json-value-boundaries)) takes FQNs
832
+ of its FQN Kind; install translates each FQN into the id of the installing
833
+ Organization's record and fails when one does not resolve. Other fields
834
+ keep their literal values. A Knowledge scope, for example, is the
835
+ `allowedDomainIds` and `allowedEntitySchemaIds` fields of the Knowledge
836
+ tools' form.
837
+ - `description` is the text the model reads for this binding in place of the
838
+ tool's own description.
830
839
  - `approval: { rule }` names an approval rule of the installing Organization;
831
840
  install fails when no rule has that name.
832
- - A `(tool, name)` pair binds once; a repeat throws at authoring and fails
841
+ - A blank `name`, `description` or approval rule throws at authoring. A
842
+ `(tool, name)` pair binds once; a repeat throws at authoring and fails
833
843
  install.
834
844
 
835
845
  Manifests store every entry as a `ToolBindingDeclaration` with FQN strings.
836
846
  Manifest readers also accept a bare FQN string, the form manifests used before
837
- binding controls; `toolBindingDeclaration` reads either form.
847
+ binding controls; `toolBindingDeclaration` reads either form. Readers refuse a
848
+ binding object with any other member, such as the removed `knowledge` scope.
849
+
850
+ #### Typed settings with `bindTool`
851
+
852
+ `bindTool(reference, { name, description, approval, settings })` makes a
853
+ `tools` entry whose `settings` TypeScript checks against the tool's Binding
854
+ Settings wire type. `reference` is a same-package tool handle, which
855
+ `declareTool` types from its `bindingSettings` form, or a
856
+ `TypedToolReference<Settings>` that names another package's tool, such as a
857
+ reference that a generated catalog writes. A key that the wire type does not
858
+ define is a type error. A string field, or an item of a string-list field,
859
+ also takes a declaration handle.
860
+
861
+ ```ts
862
+ const memberSearch = declareTool({
863
+ definition: { bindingSettings: memberSearchForm, input, output },
864
+ ...
865
+ })
866
+
867
+ declareSkill({
868
+ definition: {
869
+ instructions: "# Member search",
870
+ lifecycle,
871
+ tools: [
872
+ bindTool(memberSearch, {
873
+ description: "Search the member companies",
874
+ settings: { allowedDomainIds: [membersDomain], limit: 10 }
875
+ })
876
+ ]
877
+ },
878
+ ...
879
+ })
880
+ ```
881
+
882
+ - `declareAgent` and `declareSkill` write a handle that is a top-level
883
+ `settings` value, or an item of a top-level list, as its FQN. A handle at
884
+ any other place throws a `TypeError` that names the settings path, for
885
+ example `settings.filter.schema`. Install refuses a handle of the wrong FQN
886
+ Kind, because its FQN does not resolve.
887
+ - The wire type is type-only: the handle and the reference hold no runtime
888
+ value for it. A tool without a `bindingSettings` form takes no settings; a
889
+ form whose schema hides its wire type, such as a value typed
890
+ `FormDefinition`, takes any JSON object.
891
+ - A plain `ToolBinding` keeps JSON `settings`, with a handle or an FQN string
892
+ as `tool`. TypeScript does not check them against the form, and a
893
+ declaration handle is not a JSON value; install still checks them. A plain
894
+ FQN string carries no settings type, so `bindTool` does not take one.
838
895
 
839
896
  ## Organization Group declarations
840
897
 
@@ -1592,8 +1649,22 @@ reason rather than silently degrading.
1592
1649
  `interactive_form` also admits `UnrestrictedScopeKeyword`
1593
1650
  (`"x-unrestricted-scope": true`) on a boolean binding-settings field whose
1594
1651
  enabled value lifts the binding's scope restrictions. The host, not the
1595
- package, decides which authority may enable it. The Effect adapter projects
1596
- this annotation; other custom annotations are not projected.
1652
+ package, decides which authority may enable it.
1653
+
1654
+ `interactive_form` also admits `FqnOfKeyword` (`"x-fqn-of"`) on a
1655
+ binding-settings field that holds ids of platform records. Its value is one
1656
+ `FqnKind`: `FqnKind.KnowledgeDomain` (`"knowledge-domain"`) or
1657
+ `FqnKind.KnowledgeEntitySchema` (`"knowledge-entity-schema"`). The profile
1658
+ refuses an unknown kind, and the keyword on a field that is not a top-level
1659
+ string or a top-level list of strings. The form describes the stored ids; a
1660
+ package that binds the tool writes FQNs in the field, and install translates
1661
+ them into the installing Organization's ids. The Effect adapter projects both
1662
+ keywords; other custom annotations are not projected.
1663
+
1664
+ A Binding Settings Form cannot define a host key. `HostBindingSettingKeys`
1665
+ (`approvalMode`, `approvalRuleId`) are the approval keys the host owns in the
1666
+ binding settings of every tool. `declareTool` throws a `TypeError`, and the tool
1667
+ manifest reader refuses a form that defines one.
1597
1668
 
1598
1669
  Tool inputs default to `ai_function_input`, matching the host's default skill
1599
1670
  exposure. A tool that explicitly declares only non-AI scopes such as
@@ -1,9 +1,9 @@
1
1
  import type { AccessAudience, AccessAudienceDeclaration } from "../access/audience.js";
2
- import type { JsonObject } from "../foundation/json.js";
2
+ import type { JsonObject, JsonValue } from "../foundation/json.js";
3
3
  import type { PackageSchemaProjection } from "../schema/projection.js";
4
4
  import type { PackageCodecSource } from "../schema/source.js";
5
- import type { ComponentManifest, ComponentPresentation, DeclarationReference, DeclaredComponent } from "./authoring-core.js";
6
- import type { PackagePrimitiveBase } from "./base.js";
5
+ import type { ComponentManifest, ComponentPresentation, DeclarationHandle, DeclarationReference, DeclaredComponent } from "./authoring-core.js";
6
+ import type { PackagePrimitiveBase, PackagePrimitiveKind } from "./base.js";
7
7
  import type { DataAccess } from "./data-access.js";
8
8
  import type { LifecycleOptions } from "./lifecycle.js";
9
9
  /** Idle activation sources. Each stays off unless declared `true`. */
@@ -19,43 +19,77 @@ export type AgentActivityPolicy = Readonly<{
19
19
  export type ToolBindingApproval = "always" | "never" | Readonly<{
20
20
  rule: string;
21
21
  }>;
22
- /** Knowledge definitions a binding includes or excludes, by reference. */
23
- export type KnowledgeScopeSelection<Reference> = Readonly<{
24
- exclude?: readonly Reference[];
25
- include?: readonly Reference[];
26
- }>;
27
- type KnowledgeScopeOf<Domain, EntitySchema> = Readonly<{
28
- domains?: KnowledgeScopeSelection<Domain>;
29
- entitySchemas?: KnowledgeScopeSelection<EntitySchema>;
30
- /** Lifts the scope boundary; the installer still needs the bind permission. */
31
- unrestricted?: boolean;
32
- }>;
33
22
  /**
34
- * Portable Knowledge boundary of a binding. Install resolves each reference
35
- * to the Organization's definition and rejects one that does not resolve, or
36
- * a boundary on a tool that has no Knowledge scope.
37
- */
38
- export type ToolBindingKnowledgeScope = KnowledgeScopeOf<DeclarationReference<"domain">, DeclarationReference<"knowledgeEntitySchema">>;
39
- /**
40
- * One tool an Agent or Skill binds, with the controls the binding carries.
41
- * `settings` is validated at install against the tool's binding settings
42
- * form. A tool may be bound several times under distinct `name`s.
23
+ * One tool an Agent or Skill binds. `name`, `description` and `approval` are
24
+ * host controls, the same for every tool; `settings` holds the tool's own
25
+ * options and is validated at install against the tool's binding settings
26
+ * form, whose `x-fqn-of` fields take FQNs. `description` replaces the tool's
27
+ * description for the model. A tool may be bound several times under
28
+ * distinct `name`s.
43
29
  */
44
30
  export type ToolBinding = Readonly<{
45
31
  approval?: ToolBindingApproval;
46
- knowledge?: ToolBindingKnowledgeScope;
32
+ description?: string;
47
33
  name?: string;
48
34
  settings?: JsonObject;
49
35
  tool: DeclarationReference<"tool">;
50
36
  }>;
37
+ /**
38
+ * The keys a tool binding holds. Tool options go in `settings`, so any other
39
+ * key, such as the removed `knowledge`, is refused.
40
+ */
41
+ export declare const toolBindingKeys: readonly ["approval", "description", "name", "settings", "tool"];
51
42
  /** A `ToolBinding` in a manifest: every reference is an FQN. */
52
- export type ToolBindingDeclaration = Readonly<{
53
- approval?: ToolBindingApproval;
54
- knowledge?: KnowledgeScopeOf<string, string>;
55
- name?: string;
56
- settings?: JsonObject;
43
+ export type ToolBindingDeclaration = Omit<ToolBinding, "tool"> & Readonly<{
44
+ tool: string;
45
+ }>;
46
+ declare const bindingSettingsWire: unique symbol;
47
+ /**
48
+ * A tool reference typed by the tool's Binding Settings wire type: the handle
49
+ * `declareTool` returns, or a reference to another package's tool, such as
50
+ * one that a generated catalog writes. The wire type is type-only; it has no
51
+ * runtime value.
52
+ */
53
+ export type TypedToolReference<Settings extends object> = Readonly<{
54
+ manifest: Readonly<{
55
+ fqn: string;
56
+ kind: "tool";
57
+ }>;
58
+ [bindingSettingsWire]?: Settings;
59
+ }>;
60
+ type SettingsHandle = DeclarationHandle<PackagePrimitiveKind>;
61
+ /** A string may also be a declaration handle, written as its FQN. */
62
+ type FqnInput<Value> = Value extends string ? Value | SettingsHandle : Value;
63
+ /** A `settings` value: a string field or a string-list item takes a handle. */
64
+ type SettingInput<Value> = Value extends readonly (infer Item)[] ? readonly FqnInput<Item>[] : FqnInput<Value>;
65
+ /** `settings` typed from a Binding Settings wire type. */
66
+ type TypedToolSettings<Settings> = {
67
+ readonly [Key in keyof Settings]: SettingInput<Settings[Key]>;
68
+ };
69
+ /** A `settings` value at run time: JSON, or a handle where an FQN goes. */
70
+ type SettingValue = SettingInput<JsonValue>;
71
+ type BindToolOptions<Settings> = Omit<ToolBinding, "settings" | "tool"> & Readonly<{
72
+ settings?: Settings;
73
+ }>;
74
+ /** Marks a `bindTool` result, so that a plain binding keeps JSON settings. */
75
+ declare const boundTool: unique symbol;
76
+ /**
77
+ * A binding that `bindTool` makes. Its `settings` may hold a declaration
78
+ * handle as a top-level value or list item; the manifest holds the handle's
79
+ * FQN.
80
+ */
81
+ export type TypedToolBinding = BindToolOptions<Readonly<Record<string, SettingValue>>> & Readonly<{
82
+ [boundTool]: true;
57
83
  tool: string;
58
84
  }>;
85
+ /**
86
+ * Binds a tool with `settings` typed from its Binding Settings wire type: an
87
+ * unknown key is a type error, and a string field or string-list item also
88
+ * takes a declaration handle. `reference` is a same-package tool handle or a
89
+ * typed reference to another package's tool; a plain FQN string has no
90
+ * settings type, so bind it with a plain `ToolBinding`.
91
+ */
92
+ export declare function bindTool<Settings extends object>(reference: TypedToolReference<Settings>, binding: BindToolOptions<NoInfer<TypedToolSettings<Settings>>>): TypedToolBinding;
59
93
  /**
60
94
  * Declared tool bindings. Manifests published before bindings carried
61
95
  * controls list bare tool FQNs; readers keep accepting them.
@@ -118,11 +152,14 @@ type Declaration<Definition> = Readonly<{
118
152
  manifest: ComponentManifest;
119
153
  presentation: ComponentPresentation;
120
154
  }>;
155
+ /** A `tools` entry: a tool reference, a plain binding, or a `bindTool` result. */
156
+ type ToolEntry = DeclarationReference<"tool"> | ToolBinding | TypedToolBinding;
121
157
  /**
122
158
  * `skills`, `tools` and the `audience` references take same-package handles
123
159
  * or FQN strings. Strings are resolved at install, not at compile time: an
124
160
  * unknown Skill, tool, Group, profile or application rejects the package. A
125
- * `tools` entry may be a `ToolBinding` that adds the binding's controls.
161
+ * `tools` entry may be a `ToolBinding` that adds the binding's controls, or a
162
+ * `bindTool` result that also types its `settings`.
126
163
  */
127
164
  export type AgentDefinitionInput = Omit<DefinitionOf<AgentDeclaration>, "audience" | "output" | "skills" | "tools"> & Readonly<{
128
165
  audience?: AccessAudience;
@@ -130,15 +167,15 @@ export type AgentDefinitionInput = Omit<DefinitionOf<AgentDeclaration>, "audienc
130
167
  schema: PackageCodecSource;
131
168
  }>;
132
169
  skills: readonly DeclarationReference<"skill">[];
133
- tools: readonly (DeclarationReference<"tool"> | ToolBinding)[];
170
+ tools: readonly ToolEntry[];
134
171
  }>;
135
172
  /**
136
- * `tools` take same-package handles, FQN strings resolved at install, or
137
- * `ToolBinding`s, exactly as an Agent's do.
173
+ * `tools` take same-package handles, FQN strings resolved at install,
174
+ * `ToolBinding`s or `bindTool` results, exactly as an Agent's do.
138
175
  */
139
176
  export type SkillDefinitionInput = Omit<DefinitionOf<SkillDeclaration>, "audience" | "tools"> & Readonly<{
140
177
  audience?: AccessAudience;
141
- tools: readonly (DeclarationReference<"tool"> | ToolBinding)[];
178
+ tools: readonly ToolEntry[];
142
179
  }>;
143
180
  /** Declares an Organization Agent materialized by package install. */
144
181
  export declare const declareAgent: (input: Declaration<AgentDefinitionInput>) => DeclaredComponent<AgentDeclaration>;
@@ -1,13 +1,36 @@
1
- import type { JsonValue } from "../foundation/json.js";
2
- import type { FormSchemaSource } from "../schema/forms.js";
3
- import type { SchemaValue } from "../schema/source.js";
1
+ import type { JsonObject, JsonValue } from "../foundation/json.js";
2
+ import type { FormDefinition, FormSchemaSource, PortableFormDefinition } from "../schema/forms.js";
3
+ import type { SchemaValue, SchemaWire } from "../schema/source.js";
4
+ import type { TypedToolReference } from "./agents.js";
4
5
  import type { ClassDeclaration, ClassDeclaredComponent, ConnectionClassDeclaration, ConnectionImplementation, EventListenerClassDeclaration, EventListenerImplementation, DocumentsConnectorClassDeclaration, DocumentsConnectorImplementation, FieldTransformerClassDeclaration, FieldTransformerImplementation, KnowledgeConnectorClassDeclaration, KnowledgeConnectorImplementation, KnowledgeConnectorOAuthClassDeclaration, KnowledgeConnectorOAuthImplementation, KnowledgeEntityAdapterClassDeclaration, KnowledgeEntityAdapterImplementation, NotificationChannelClassDeclaration, NotificationChannelImplementation, ToolClassDeclaration, ToolImplementation, ToolSettingsOptionsClassDeclaration, ToolSettingsOptionsImplementation, WorkflowFieldClassDeclaration, WorkflowFieldImplementation, WorkflowFieldValue } from "./authoring-core.js";
5
6
  import type { ConnectionDeclaration, DocumentsConnectorDeclaration, EmailProviderDeclaration, EventListenerDeclaration, InboundMessagingProviderDefinition, KnowledgeConnectorDeclaration, KnowledgeConnectorOAuthDeclaration, KnowledgeEntityAdapterDeclaration, OrganizationSsoDeclaration, OutboundMessagingProviderDeclaration } from "./connectors.js";
6
7
  import type { DatasetParserImplementation } from "./dataset-parser.js";
7
8
  import type { FieldTransformerDeclaration, NotificationChannelDeclaration, ToolDeclaration, ToolSettingsOptionsDeclaration } from "./tools.js";
8
9
  import type { WorkflowFieldDeclaration } from "./workflows.js";
9
- /** Declares an executable component as a portable manifest plus owned class. */
10
- export declare const declareTool: <InputSchema, OutputSchema, Constructor extends new () => ToolImplementation<SchemaValue<InputSchema>, SchemaValue<OutputSchema>>>(input: ToolClassDeclaration<InputSchema, OutputSchema, Constructor>) => ClassDeclaredComponent<ToolDeclaration, Constructor>;
10
+ /** An object wire type, or any JSON object when the wire type is erased. */
11
+ type ObjectWire<Wire> = [Wire] extends [never] ? JsonObject : Wire extends object ? Wire : JsonObject;
12
+ /**
13
+ * The Binding Settings wire type of a tool's form. A tool without a form
14
+ * takes no settings; a form whose schema hides its wire type takes any JSON
15
+ * object.
16
+ */
17
+ type BindingSettingsWire<Form> = Form extends Readonly<{
18
+ schema: infer Schema;
19
+ }> ? ObjectWire<SchemaWire<Schema>> : Readonly<Record<string, never>>;
20
+ /**
21
+ * Refuses a Binding Settings Form that defines a host approval key: the host
22
+ * owns approval for every tool. `location` prefixes each field pointer.
23
+ */
24
+ export declare const assertNoHostKeys: (form: PortableFormDefinition, location: string) => void;
25
+ /**
26
+ * Declares an executable component as a portable manifest plus owned class.
27
+ * The handle carries the `bindingSettings` wire type for `bindTool`.
28
+ */
29
+ export declare const declareTool: <InputSchema, OutputSchema, Constructor extends new () => ToolImplementation<SchemaValue<InputSchema>, SchemaValue<OutputSchema>>, BindingSettings extends FormDefinition | undefined = undefined>(input: ToolClassDeclaration<InputSchema, OutputSchema, Constructor> & Readonly<{
30
+ definition: Readonly<{
31
+ bindingSettings?: BindingSettings;
32
+ }>;
33
+ }>) => ClassDeclaredComponent<ToolDeclaration, Constructor> & TypedToolReference<BindingSettingsWire<BindingSettings>>;
11
34
  export declare const declareConnection: <Schema extends FormSchemaSource, Constructor extends new () => ConnectionImplementation<SchemaValue<Schema>>>(input: ConnectionClassDeclaration<Schema, Constructor>) => ClassDeclaredComponent<ConnectionDeclaration, Constructor>;
12
35
  export declare const declareDocumentsConnector: <Constructor extends new () => DocumentsConnectorImplementation>(input: DocumentsConnectorClassDeclaration<Constructor>) => ClassDeclaredComponent<DocumentsConnectorDeclaration, Constructor>;
13
36
  export declare const declareKnowledgeConnector: <Schema extends FormSchemaSource, Constructor extends new () => KnowledgeConnectorImplementation>(input: KnowledgeConnectorClassDeclaration<Schema, Constructor> & (InstanceType<Constructor> extends DatasetParserImplementation ? never : unknown)) => ClassDeclaredComponent<KnowledgeConnectorDeclaration, Constructor>;
@@ -41,3 +64,4 @@ export type OutboundMessagingProviderImplementation = Readonly<{
41
64
  }>;
42
65
  /** Declares an **Outbound Messaging Provider** with its one `send` operation. */
43
66
  export declare const declareOutboundMessagingProvider: <Constructor extends new () => OutboundMessagingProviderImplementation>(input: ClassDeclaration<OutboundMessagingProviderDeclaration, Constructor>) => ClassDeclaredComponent<OutboundMessagingProviderDeclaration, Constructor>;
67
+ export {};
package/dist/index.d.ts CHANGED
@@ -10,7 +10,7 @@ export { knowledgeRecordSchema } from "./schema/knowledge-record.js";
10
10
  export type { KnowledgeFieldAuthoring, KnowledgeFieldType, KnowledgeRecordAuthoring } from "./schema/knowledge-record.js";
11
11
  export { normalizeJsonSchemaProjection } from "./schema/normalization.js";
12
12
  export { Draft202012Dialect, normalizePackageSchemaProjection } from "./schema/projection.js";
13
- export { assertConsumerProfile, ConsumerProfileIds, ConsumerProfiles, SchemaConsumerProfiles, UnrestrictedScopeKeyword, validateConsumerProfile } from "./schema/profiles.js";
13
+ export { assertConsumerProfile, ConsumerProfileIds, ConsumerProfiles, FqnKind, FqnOfKeyword, HostBindingSettingKeys, SchemaConsumerProfiles, UnrestrictedScopeKeyword, validateConsumerProfile } from "./schema/profiles.js";
14
14
  export type { OperationDomainDeclaration, PortableGatewayDeclarations, PortableOperationAuthorization, PortableOperationDeclaration, PortableOperationDelegatedSubjectPolicy, PortableOperationEffect, PortableOperationExecutionPolicy, PortableOperationIdempotency, PortableOperationLimits, PortableOperationPrincipalKind, PortableOperationRetryPolicy } from "./gateway/declarations.js";
15
15
  export type { PackageCodec, PackageCodecSource, PackageDecoder, PackageDecoderSource, PackageSchemaDefinition, PackageSchemaIssue, PackageSchemaProjections, PackageSchemaResult, PackageSchemaSource, SchemaDirection, SchemaValue, SchemaWire } from "./schema/source.js";
16
16
  export type { JsonSchemaDocument, PackageSchemaProjection, ProjectionFidelity } from "./schema/projection.js";
@@ -62,8 +62,8 @@ export { organizationInstructionsViolation } from "./components/organization-ins
62
62
  export type { OrganizationInstructionsDeclaration, VaryingOrganizationInstructions } from "./components/organization-instructions.js";
63
63
  export { organizationSettingsViolation } from "./components/organization-settings.js";
64
64
  export type { OrganizationSettingsApplicationConsent, OrganizationSettingsAuthentication, OrganizationSettingsDeclaration, OrganizationSettingsLocalMethod, OrganizationSettingsMedia, OrganizationSettingsSso, VaryingOrganizationSettings } from "./components/organization-settings.js";
65
- export { declareAgent, declareSkill, duplicateToolBinding, toolBindingDeclaration } from "./components/agents.js";
66
- export type { AgentActivityPolicy, AgentDeclaration, AgentDefinitionInput, AgentModelTier, DeclaredToolBindings, KnowledgeScopeSelection, SkillDeclaration, SkillDefinitionInput, ToolBinding, ToolBindingApproval, ToolBindingDeclaration, ToolBindingKnowledgeScope } from "./components/agents.js";
65
+ export { bindTool, declareAgent, declareSkill, duplicateToolBinding, toolBindingDeclaration } from "./components/agents.js";
66
+ export type { AgentActivityPolicy, AgentDeclaration, AgentDefinitionInput, AgentModelTier, DeclaredToolBindings, SkillDeclaration, SkillDefinitionInput, ToolBinding, ToolBindingApproval, ToolBindingDeclaration, TypedToolBinding, TypedToolReference } from "./components/agents.js";
67
67
  export type { DocumentsDeltaCursorExpired, DocumentsDeltaItem, DocumentsDeltaPage, DocumentsDeltaRequest, DocumentsDrive, DocumentsDrivesPage, DocumentsFolder, DocumentsFoldersPage, DocumentsFetchedContent, DocumentsFileRevision, DocumentsRootAncestry, DocumentsSource, DocumentsSyncWarning, KnowledgeEntityAdapterDeclaration, ConnectionDeclaration, DatasetParserDeclaration, ExternalDatasetProviderDeclaration, KnowledgeConnectorContribution, KnowledgeConnectorBindingExtraConfig, KnowledgeConnectorDeclaration, KnowledgeConnectorRemoteDeletion, KnowledgeConnectorFieldMapRule, KnowledgeEntitySchemaCapability, KnowledgeConnectorOAuthDeclaration, KnowledgeConnectorOAuthTokens, KnowledgeConnectorRemoteReference, EventListenerDeclaration, EventListenerInternalOccurrence, EventListenerPollRequest, EventListenerPollResult, EventListenerWebhookRequest, KnowledgePredefinedSchedule, ManagedDatasetProviderDeclaration } from "./components/connectors.js";
68
68
  export type { PackagePrimitiveDeclaration } from "./components/declaration.js";
69
69
  export type { DatasetBlueprintClassDeclaration, DatasetBlueprintDeclaration, DatasetTableTemplateClassDeclaration, DatasetTableTemplateDeclaration, DatasetTableTemplateHint, DatasetTableTemplatePhysicalCode, DatasetTableTemplateSemanticRole, DatasetTableTemplateUniqueness } from "./components/templates.js";