@mawaru/sdk 0.11.0 → 0.14.1

package/_schemas/graph.test.ts

@@ -8,7 +8,7 @@ import {
   waitConfigSchema,
 } from "./graph.js"
 import type { GraphPort } from "./node.js"
-import { envelopeSchemaOf, resolvePortSchemas } from "./port-spec.js"
+import { resolvePortSchemas } from "./port-spec.js"
 
 // テスト用の決定的な uuid（common は node 型定義を持たないため crypto は使わない）
 let seq = 0
@@ -89,15 +89,14 @@ const port = (io: "in" | "out", key: string): GraphPort => ({
   schema: { type: "object" },
 })
 
-// ai の out 宣言は封筒型 { data, description } 固定なので、デフォルトノードは
-// data=テキストの封筒を持つ
-const textEnvelope = envelopeSchemaOf({ type: "string" })
+// ai の out も自由な宣言型。デフォルトノードはテキスト（string）を宣言する
+const textOutput = { type: "string" }
 
 // 既定は ai ノード。ai の in は 上流データの in ＋ 差し戻しの instruction の2口
 const aiPorts = (): GraphPort[] => [
   port("in", "in"),
   port("in", "instruction"),
-  { ...port("out", "main"), schema: textEnvelope },
+  { ...port("out", "main"), schema: textOutput },
 ]
 
 // ai 以外に流用するとき用（in は1つ）
@@ -153,8 +152,8 @@ describe("programConfigSchema", () => {
 
 describe("aiConfigSchema", () => {
   it("ai_dir を受け付ける（ref は省略可・日本語可）", () => {
-    expect(aiConfigSchema.parse({ ai_dir: "draftReply" })).toEqual({
-      ai_dir: "draftReply",
+    expect(aiConfigSchema.parse({ ai_dir: "replyComposer" })).toEqual({
+      ai_dir: "replyComposer",
     })
     expect(
       aiConfigSchema.parse({ ai_dir: "返信下書き", ref: "develop" }).ref,
@@ -181,14 +180,12 @@ describe("humanConfigSchema", () => {
 
   // 承認ビューは不透明なキー（program_dir / ai_dir と同じ）。実在するか・そのテナントが
   // 選べるかは mawaru 側のカタログ（非公開）と保存 API が見るので、ここは形だけ
-  it("承認ビューとそのパラメータを受け付ける", () => {
+  it("承認ビューを受け付ける", () => {
     const parsed = humanConfigSchema.parse({
       assignment: {},
       view: "acme/invoice",
-      view_config: { threshold: 1000 },
     })
     expect(parsed.view).toBe("acme/invoice")
-    expect(parsed.view_config).toEqual({ threshold: 1000 })
   })
 
   it("空のビューキーは拒否する", () => {
@@ -390,17 +387,27 @@ describe("saveGraphBodySchema", () => {
     ).toThrow(/key が重複/)
   })
 
-  it("in ポートがちょうど1つでない node を拒否する（0個・2個）", () => {
+  it("in ポートの口数：ai は1つ以上（自由）、program 等は ちょうど1つ", () => {
+    // ai：0個は拒否、複数は許可（in の追加・削除は自由）
     const zero = makeNode([port("out", "main")])
     expect(() =>
       saveGraphBodySchema.parse({ nodes: [zero], connections: [] }),
     ).toThrow(/in ポート/)
-
-    const two = makeNode([
+    const many = makeNode([
       port("in", "in"),
-      port("in", "in2"),
+      port("in", "feedback"),
+      port("in", "extra"),
       port("out", "main"),
     ])
+    expect(() =>
+      saveGraphBodySchema.parse({ nodes: [many], connections: [] }),
+    ).not.toThrow()
+
+    // program：ちょうど1つ
+    const two = {
+      ...makeNode([port("in", "in"), port("in", "in2"), port("out", "main")]),
+      kind: "program" as const,
+    }
     expect(() =>
       saveGraphBodySchema.parse({ nodes: [two], connections: [] }),
     ).toThrow(/in ポート/)
@@ -499,8 +506,6 @@ describe("saveGraphBodySchema", () => {
 
 // ---- kind 別ポート構成と型の接続バリデーション（ポートのkind別仕様.md） ----
 
-const aiEnvelope = textEnvelope
-
 const humanNode = () => ({
   ...makeNode([
     port("in", "in"),
@@ -513,7 +518,7 @@ const aiNode = () => ({
   ...makeNode([
     port("in", "in"),
     port("in", "instruction"),
-    { ...port("out", "main"), schema: aiEnvelope },
+    { ...port("out", "main"), schema: textOutput },
   ]),
   kind: "ai" as const,
 })
@@ -551,27 +556,27 @@ describe("saveGraphBodySchema（kind 別ポート構成）", () => {
       ...makeNode([
         port("in", "in"),
         port("in", "instruction"),
-        { ...port("out", "spam"), schema: aiEnvelope },
-        { ...port("out", "sales"), schema: aiEnvelope },
-        { ...port("out", "support"), schema: aiEnvelope },
+        { ...port("out", "spam"), schema: textOutput },
+        { ...port("out", "sales"), schema: textOutput },
+        { ...port("out", "support"), schema: textOutput },
       ]),
       kind: "ai" as const,
     }
     expect(() =>
       saveGraphBodySchema.parse({ nodes: [multi], connections: [] }),
     ).not.toThrow()
-    // in の構成は in / instruction 固定のまま
-    const badIn = {
+    // in の key も自由（in / instruction の固定構成は廃止）
+    const freeIn = {
       ...makeNode([
         port("in", "input"),
-        port("in", "instruction"),
-        { ...port("out", "main"), schema: aiEnvelope },
+        port("in", "feedback"),
+        { ...port("out", "main"), schema: textOutput },
       ]),
       kind: "ai" as const,
     }
     expect(() =>
-      saveGraphBodySchema.parse({ nodes: [badIn], connections: [] }),
-    ).toThrow(/ai の in ポート/)
+      saveGraphBodySchema.parse({ nodes: [freeIn], connections: [] }),
+    ).not.toThrow()
   })
 
   it("program は out を複数持てる（key 自由）", () => {
@@ -588,51 +593,41 @@ describe("saveGraphBodySchema（kind 別ポート構成）", () => {
     ).not.toThrow()
   })
 
-  it("ai の出力宣言が封筒型 { data, description } でないと拒否する（全出口に適用）", () => {
-    const bad = makeNode([
-      port("in", "in"),
-      port("in", "instruction"),
-      { ...port("out", "main"), schema: { type: "object" } },
-    ])
-    expect(() =>
-      saveGraphBodySchema.parse({ nodes: [bad], connections: [] }),
-    ).toThrow(/封筒型 \{ data, description \}/)
-    // main 以外の出口も封筒型を強制する
-    const badExtra = makeNode([
-      port("in", "in"),
-      port("in", "instruction"),
-      { ...port("out", "main"), schema: aiEnvelope },
-      { ...port("out", "extra"), schema: { type: "object" } },
-    ])
-    expect(() =>
-      saveGraphBodySchema.parse({ nodes: [badExtra], connections: [] }),
-    ).toThrow(/封筒型 \{ data, description \}/)
-    // data は任意の型でよい（カタログ外の object も通る）
-    const custom = makeNode([
-      port("in", "in"),
-      port("in", "instruction"),
+  it("ai の出力宣言は任意の JSON Schema でよい（形の強制はしない）", () => {
+    for (const schema of [
+      { type: "object" },
+      { type: "string" },
+      { type: "array", items: { type: "number" } },
       {
-        ...port("out", "main"),
-        schema: envelopeSchemaOf({
-          type: "object",
-          properties: { title: { type: "string" } },
-          required: ["title"],
-        }),
+        // かつて強制していた { data, description } もただの object として valid
+        type: "object",
+        properties: {
+          data: { type: "string" },
+          description: { type: "string" },
+        },
+        required: ["data", "description"],
       },
-    ])
-    expect(() =>
-      saveGraphBodySchema.parse({ nodes: [custom], connections: [] }),
-    ).not.toThrow()
+    ]) {
+      const node = makeNode([
+        port("in", "in"),
+        port("in", "instruction"),
+        { ...port("out", "main"), schema },
+      ])
+      expect(() =>
+        saveGraphBodySchema.parse({ nodes: [node], connections: [] }),
+      ).not.toThrow()
+    }
   })
 })
 
 describe("saveGraphBodySchema（型の接続バリデーション）", () => {
-  it("human の reject → ai の instruction は許可。ai の in や ai 以外は拒否", () => {
+  // 接続の可否は kind ではなく型で決まる。reject / instruction の型固定は廃止され、
+  // ai の in はどの口も接続鏡映（接続元の型に同期）なので接続は自明に通る
+  // → docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md
+  it("human の reject → ai の instruction を許可（kind の縛りも型固定も無い）", () => {
     const human = humanNode()
     const ai = aiNode()
-    const prog = programNode()
     const rejectPort = outByKey(human, "reject")
-    // 差し戻しは指示の口（instruction）へ
     expect(() =>
       saveGraphBodySchema.parse({
         nodes: [human, ai],
@@ -644,43 +639,43 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
         ],
       }),
     ).not.toThrow()
-    // 上流データの口（in）には繋げない（意味の違う入力を fan-in させない）
-    expect(() =>
-      saveGraphBodySchema.parse({
-        nodes: [human, ai],
-        connections: [
-          { from_port_id: rejectPort.id, to_port_id: inByKey(ai, "in").id },
-        ],
-      }),
-    ).toThrow(/instruction/)
-    // ai 以外にも繋げない
+  })
+
+  it("reject は ai 以外へも繋げる（接続鏡映の in が接続元の型を採用する）", () => {
+    const human = humanNode()
+    const prog = programNode()
     expect(() =>
       saveGraphBodySchema.parse({
         nodes: [human, prog],
         connections: [
-          { from_port_id: rejectPort.id, to_port_id: inOf(prog).id },
+          {
+            from_port_id: outByKey(human, "reject").id,
+            to_port_id: inOf(prog).id,
+          },
         ],
       }),
-    ).toThrow(/instruction/)
+    ).not.toThrow()
   })
 
-  it("instruction ポートに繋げるのは human の reject だけ", () => {
-    const ai = aiNode()
-    const prog = programNode()
+  it("instruction も他の in と同じ接続鏡映：宣言と違う型の out でも同期して繋がる", () => {
+    const upstream = aiNode()
+    const downstream = aiNode()
+    // ai.main は string、instruction の宣言は { type: "object" } だが、
+    // 鏡映で接続元に同期される（instruction の特別扱いは無い）
     expect(() =>
       saveGraphBodySchema.parse({
-        nodes: [prog, ai],
+        nodes: [upstream, downstream],
         connections: [
           {
-            from_port_id: outOf(prog).id,
-            to_port_id: inByKey(ai, "instruction").id,
+            from_port_id: outOf(upstream).id,
+            to_port_id: inByKey(downstream, "instruction").id,
           },
         ],
       }),
-    ).toThrow(/instruction ポートに接続できるのは/)
+    ).not.toThrow()
   })
 
-  it("human の in はどの型でも接続できる（封筒型の制約は課さない）", () => {
+  it("human の in はどの型でも接続できる（形の制約は課さない）", () => {
     const ai = aiNode()
     const human = humanNode()
     expect(() =>
@@ -690,8 +685,7 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
       }),
     ).not.toThrow()
 
-    // program out が封筒型でない（{ type: "object" } のまま）でも接続できる
-    // （input 全体を data として表示する）
+    // program out が素の object でも接続できる
     const human2 = humanNode()
     const progPlain = {
       ...makeNode([
@@ -709,7 +703,8 @@ describe("saveGraphBodySchema（型の接続バリデーション）", () => {
   })
 
   it("program の in への接続は 伝播型 ⊆ 宣言スキーマ（human 経由の伝播込み）", () => {
-    // ai(封筒型) → human(approve は data 型に剥がれる) → program(string を要求) は通る
+    // ai → human（approve は in と同型）→ program(string を要求) は、
+    // program の in が接続鏡映（sticky）なので通る
     const ai = aiNode()
     const human = humanNode()
     const prog = programNode({ type: "string" })
@@ -1029,6 +1024,30 @@ describe("saveGraphBodySchema：コンポーネントノード（component kind
     ).not.toThrow()
   })
 
+  it("component.refs（配置の設定値）を受け付けて保持する（省略も可）", () => {
+    const withRefs = {
+      ...componentNode(),
+      component: {
+        component_loop_id: uuid(),
+        refs: { labels: ["bug"], assignee: "kazuwombat" },
+      },
+    }
+    const parsed = saveGraphBodySchema.parse({
+      nodes: [withRefs],
+      connections: [],
+    })
+    expect(parsed.nodes[0]?.component?.refs).toEqual({
+      labels: ["bug"],
+      assignee: "kazuwombat",
+    })
+    // 省略時は undefined のまま（既存グラフの互換。保存側で {} 扱い）
+    const omitted = saveGraphBodySchema.parse({
+      nodes: [componentNode()],
+      connections: [],
+    })
+    expect(omitted.nodes[0]?.component?.refs).toBeUndefined()
+  })
+
   it("component_loop_id の無い component ノードを拒否する", () => {
     const node = { ...componentNode(), component: undefined }
     expect(() =>
@@ -1068,7 +1087,7 @@ describe("saveGraphBodySchema：コンポーネントノード（component kind
         nodes: [prog, comp],
         connections: [connect(prog, comp)],
       }),
-    ).toThrow(/入力契約に適合しません/)
+    ).toThrow(/適合しません/)
     // 適合（string → string）なら通る
     const okComp = componentNode({ type: "string" })
     expect(() =>

package/_schemas/graph.ts

@@ -6,9 +6,7 @@ import {
   portKeySchema,
 } from "./node.js"
 import {
-  AI_INSTRUCTION_PORT_KEY,
   hasInboundConflict,
-  isAiEnvelopeSchema,
   isSchemaSubset,
   kindPortsViolation,
   resolvePortSchemas,
@@ -148,8 +146,6 @@ export const humanConfigSchema = z.object({
   // どのキーが実在するか・そのテナントが選べるかは保存時に mawaru 側が検証する
   // （カタログは非公開。@mawaru/common の approval-view.ts）。省略時は標準ビュー
   view: z.string().min(1).optional(),
-  // ビューに渡すパラメータ（列・ラベル・閾値など）。形はビューごとに違うので任意の JSON
-  view_config: z.unknown().nullish(),
   assignment: z
     .object({
       strategy: z.enum(["fixed", "round_robin"]).default("fixed"),
@@ -205,6 +201,10 @@ export type HumanConfig = z.infer<typeof humanConfigSchema>
 // （docs/tasks/wip/コンポーネント（ループの部品化と再利用）.md）
 export const componentConfigSchema = z.object({
   component_loop_id: z.uuid(),
+  // 配置の設定値：子 loop の refs 定義（default/required）への上書き。
+  // 子 run 起動時の起動時指定として渡る（省略＝上書きなし。検証は保存 API と
+  // 起動時の mergeRefs が行う。コンポーネントの設定値（refs）と1ノードのコンポーネント化.md）
+  refs: z.record(z.string(), z.unknown()).optional(),
 })
 export type ComponentConfig = z.infer<typeof componentConfigSchema>
 
@@ -318,19 +318,18 @@ export const saveGraphBodySchema = z
         else outCount++
       })
       // end は「in は1つ以上」（複数ルートを別々の in で集約する）。
-      // ai は2つ（上流データの in ＋ 差し戻しの instruction）。他 kind は1つ固定。
+      // ai も1つ以上（in は自由ポート：追加・削除・key 自由）。他 kind は1つ固定。
       // key の妥当性は kindPortsViolation が別途見る
-      const expectIn = node.kind === "ai" ? 2 : 1
       const inCountOk =
-        node.kind === "end" ? inCount >= 1 : inCount === expectIn
+        node.kind === "end" || node.kind === "ai" ? inCount >= 1 : inCount === 1
       if (!inCountOk) {
         ctx.addIssue({
           code: "custom",
           path: ["nodes", i, "ports"],
           message:
-            node.kind === "end"
+            node.kind === "end" || node.kind === "ai"
               ? "in ポートが1つ以上必要です"
-              : `in ポートはちょうど${expectIn}つ必要です`,
+              : "in ポートはちょうど1つ必要です",
         })
       }
       if (outCount < 1) {
@@ -373,7 +372,8 @@ export const saveGraphBodySchema = z
         })
       }
 
-      // kind 別のポート構成（program 以外は数・key・io 固定。ポートのkind別仕様.md）
+      // kind 別のポート構成（program 以外は数・key・io 固定。ポートのkind別仕様.md）。
+      // ポートのスキーマ自体は kind によらず任意の JSON Schema（形の強制はしない）
       const violation = kindPortsViolation(node.kind, node.ports)
       if (violation) {
         ctx.addIssue({
@@ -382,21 +382,6 @@ export const saveGraphBodySchema = z
           message: violation,
         })
       }
-
-      // AI の出力宣言は封筒型 { data: T, description: string }（T は任意の JSON Schema）。
-      // 複数出口でも全出口に強制する（どの出口も human に接続できる不変条件）
-      if (node.kind === "ai") {
-        node.ports.forEach((port, j) => {
-          if (port.io === "out" && !isAiEnvelopeSchema(port.schema)) {
-            ctx.addIssue({
-              code: "custom",
-              path: ["nodes", i, "ports", j],
-              message:
-                "AI の出力は封筒型 { data, description } で宣言してください",
-            })
-          }
-        })
-      }
     })
 
     // 接続：両端がグラフ内の port を指し、from=out / to=in。
@@ -482,64 +467,22 @@ export const saveGraphBodySchema = z
         })
       }
 
-      // human の reject の接続先は AI の instruction ポートのみ。
-      // 差し戻しは「元のセッションに指示を与える」操作で、上流データの口（in）とは
-      // 意味が違う（docs/tasks/wip/ポートスキーマのany撲滅.md）
-      if (
-        fromNode.kind === "human" &&
-        from.key === "reject" &&
-        !(toNode.kind === "ai" && to.key === AI_INSTRUCTION_PORT_KEY)
-      ) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["connections", i, "to_port_id"],
-          message:
-            "差し戻し（reject）の接続先は AI ノードの instruction ポートのみです",
-        })
-      }
-
-      // instruction ポートに繋げるのは human の reject だけ（データを流し込ませない）
-      if (
-        toNode.kind === "ai" &&
-        to.key === AI_INSTRUCTION_PORT_KEY &&
-        !(fromNode.kind === "human" && from.key === "reject")
-      ) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["connections", i, "to_port_id"],
-          message:
-            "instruction ポートに接続できるのは human の差し戻し（reject）だけです",
-        })
-      }
+      // 差し戻し（reject）と instruction の組み合わせに kind の縛りも型固定も無い：
+      // reject の型はビューの宣言、instruction は ai の in の1つ（接続鏡映）でしかない
+      // → docs/tasks/wip/ポート型固定の撤去とセッション再開のポート属性化.md
 
+      // 型検証は kind によらず常に 伝播型（out） ⊆ 伝播型（in）。
+      // 未宣言は unknown＝判断できないので通す（作りかけのグラフを保存できなくしない）。
+      // 接続鏡映する口（program / ai の in）とコピー宣言のビューは接続元の型を採用する
+      // ので自明に通り、実質の検証対象は宣言で固定された口
+      // （component の契約・宣言のあるビューの human.in）になる
       const fromSchema = resolved.get(conn.from_port_id) ?? from.schema
-
-      // human の in はどの型でも接続できる（上流が AI なら封筒 { data, description }、
-      // それ以外は input 全体を data として表示する。型制約は課さない）
-
-      // program の in への接続は 伝播型 ⊆ 宣言スキーマ。in は接続鏡映（sticky）なので
-      // 具体型の接続では自明に通り、接続元が未宣言 × 宣言維持のときだけ従来の意味を持つ
-      // （未宣言は unknown＝判断できないので通す。作りかけのグラフを保存できなくしない）
       const toSchema = resolved.get(conn.to_port_id) ?? to.schema
-      if (toNode.kind === "program" && !isSchemaSubset(fromSchema, toSchema)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["connections", i, "to_port_id"],
-          message:
-            "接続元の型が program の入力スキーマに適合しません（伝播型 ⊆ 宣言スキーマ）",
-        })
-      }
-
-      // component の in は子 loop の契約（焼き込み済み宣言）。program と同じ包含チェック
-      if (
-        toNode.kind === "component" &&
-        !isSchemaSubset(fromSchema, toSchema)
-      ) {
+      if (!isSchemaSubset(fromSchema, toSchema)) {
         ctx.addIssue({
           code: "custom",
           path: ["connections", i, "to_port_id"],
-          message:
-            "接続元の型がコンポーネントの入力契約に適合しません（伝播型 ⊆ 契約）",
+          message: `「${fromNode.name}」の出力が「${toNode.name}」の入力スキーマに適合しません`,
         })
       }
     })

package/_schemas/node.ts

@@ -47,6 +47,10 @@ export const graphPortSchema = z
     key: portKeySchema,
     name: z.string().min(1),
     schema: jsonSchemaSchema,
+    // in ポートの実行属性：true ならこの口から届いた実行は前回セッションを復元して
+    // 再開する（AI ノードで意味を持つ。key ではなくこの属性が再開を決める。
+    // ポート型固定の撤去とセッション再開のポート属性化.md）
+    resume: z.boolean().optional(),
     side: portSideSchema.optional(),
     offset: z.number().min(0).max(1).optional(),
   })