Configure Memory

Mints the Configure link that fixes access for the current user — sign-in, app connect, or permission grant. This is the tool for two situations: a Configure tool result says authorization_required (the user is not signed in), or the user asks to sign in or connect an app. The user's data exists behind sign-in, so "I have nothing on you" would be inaccurate in that state; what serves the user is knowing sign-in is the blocker and having the returned link, on its own line where it is easy to click. Retrying the failed call returns the same result until the user has signed in. Links exist only as this tool mints them — a hand-built link fails — and when a tool result already carries a link, that link is the one the user needs (minting another creates a second, competing session). Not the first call of a conversation (that is configure_profile_read), and not the fix for error -32009 (that is configure_profile_commit). For a signed-in user: app (gmail, calendar, drive, notion, sheets) connects or reconnects that app — returns status connect_app, a link, and whether it is already connected — and capability (like gmail:send) covers a single missing permission (status permission_needed). Bringing memories in from another assistant is NOT a connect action: this tool does not do it, and a bare "connect Configure" from a signed-in user needs no argument at all — omit app unless the user names a specific app to connect. Configure derives the requester from authenticated agent metadata or MCP transport metadata; the client field is a legacy fallback hint for an unauthenticated headless client only.

{
  "type": "object",
  "properties": {
    "client": {
      "type": "string",
      "description": "Legacy fallback handle for an unauthenticated headless client whose transport supplies no identity. Never overrides an authenticated agent."
    },
    "client_name": {
      "type": "string",
      "description": "Legacy display hint for an unauthenticated headless client. Never overrides registered agent metadata."
    },
    "app": {
      "type": "string",
      "enum": [
        "gmail",
        "calendar",
        "drive",
        "notion",
        "sheets"
      ],
      "description": "Optional app to connect or reconnect for an already signed-in user. This is for third-party apps only; it does not bring memories in from other assistants (that is not a connect action — see configure_profile_import)."
    },
    "capability": {
      "type": "string",
      "enum": [
        "gmail:read",
        "gmail:send",
        "calendar:read",
        "calendar:write"
      ],
      "description": "Optional specific permission to request when the user has an app connected but not this capability (the profile read's integrations map shows which capabilities each connector has). For example, when Gmail is connected read-only and you need to send, pass capability \"gmail:send\". Returns status permission_needed with a link that asks the user for exactly that permission and why. Prefer this over app when only a capability (like send) is missing."
    },
    "purpose": {
      "type": "string",
      "description": "Optional one-line reason shown to the user on the permission page, such as \"so I can send the follow-ups you approve\". Used with capability."
    }
  }
}

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "description": "connect_app, authorization_required, session_probe_required, or permission_needed."
    },
    "connect_url": {
      "type": "string",
      "description": "Server-minted link where the user acts. Minted per session: only this exact URL works; a retyped or shortened one fails."
    },
    "instructions": {
      "type": "string"
    },
    "app": {
      "type": "string"
    },
    "connected": {
      "type": "boolean"
    },
    "capability": {
      "type": "string"
    }
  },
  "required": [
    "status"
  ],
  "additionalProperties": true
}

Read the current user's approved profile. Use the no-argument overview only when the user explicitly asks to review their profile or get a profile overview. For personalized help or a specific fact, use configure_profile_search with a concrete query about the current task; no overview is needed first. Read a known category or project box when the user asks to review it or resume that project. Three ways in. (1) No arguments: the profile overview. Returns composed context, not raw files: identity, the synthesized narrative and preference docs, key facts each tagged with their box like "[work] …", changesSince (memories newer than the synthesized summary), and a table of contents of boxes. Category boxes ("work", "preferences-and-taste", …) hold Configure's settled facts; source boxes ("agents/atlas", "imports/chatgpt") hold one agent's or import's own notes; project boxes ("projects/<slug>") are shared tags across agents. The overview is budget-bounded; when something is cut it sets truncated and names the box ids holding the rest — open those instead of re-reading. (2) sections: strict pages of the composed document, and ONLY those pages — sections: ["imports"] is the imports overview (each provider's summary and count), ["soul"] is the full soul document (voice and personality) and ["context"] the full context document (current focus), each the untruncated version of what the overview cut, ["agents"] is the connected-agent map. Use a section when you want one page cheaply. (3) box: open one shelf of STORED memories by id from the table of contents; unknown or empty boxes return a clean empty result naming the boxes that exist. A box open returns ONE PAGE: the response carries total, and when total is larger than the notes you received, call read again with page: 2, then 3, until you have them all — answering from page 1 alone silently drops the rest. For point lookups (one fact, date ranges, source attribution) or filtering by author, use configure_profile_search. An authorization challenge means the user is not signed in; configure_connect supplies the sign-in link that resolves it.

{
  "type": "object",
  "properties": {
    "sections": {
      "type": "array",
      "items": {
        "type": "string",
        "enum": [
          "identity",
          "preferences",
          "integrations",
          "imports",
          "agents",
          "summary",
          "soul",
          "context"
        ]
      },
      "description": "Strict page filter on the composed profile document: the response contains exactly the pages named here, nothing else. Omit for the profile overview (facts, boxes, sources, docs), only on an explicit profile review request. Pages: identity, preferences (interaction rules), integrations, imports, agents (connected agents), summary, soul (voice and personality), context (current focus). Pages of the composed document, not storage: to open stored memories use box; to filter by author use search with source."
    },
    "page": {
      "type": "number",
      "description": "Optional 1-based page for a box open. Each box open returns page_size facts and a total; pass page: 2 to continue a long box (project threads, big namespaces). Ignored without box."
    },
    "since": {
      "type": "string",
      "description": "Optional delta cursor for a box open (\"YYYY-MM-DD\" or an ISO timestamp): return only notes newer than this. Every box open returns latest (the newest note timestamp); store it and pass it back as since on the next open to read just what changed. Ignored without box."
    },
    "detail": {
      "type": "string",
      "enum": [
        "compact",
        "full"
      ],
      "description": "Optional box-open verbosity. Default compact truncates long notes and marks them truncated: true; pass \"full\" to read whole notes. Ignored without box."
    },
    "box": {
      "type": "string",
      "description": "Optional box id from a previous read's table of contents. A category name like \"work\" opens the settled facts in that category, ranked by value, across all sources. \"agents/<name>\" or \"imports/<provider>\" opens the notes that source saved. \"projects/<slug>\" opens a shared project tag: notes any agent filed under that box when saving, collected across sources — the pattern for cross-agent handoffs (write with that box, read it back here). Unknown or empty boxes return an empty result listing the boxes that exist; never an error."
    }
  }
}

{
  "type": "object",
  "properties": {
    "linked": {
      "type": "boolean",
      "description": "False when no Configure user is resolved for this session."
    },
    "identity": {
      "type": "object"
    },
    "boxes": {
      "type": "array",
      "description": "Table of contents: category, source and project boxes."
    },
    "sources": {
      "type": "array"
    },
    "top_facts": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Highest-value facts, each prefixed with its category id in brackets, and the source that saved it."
    },
    "changesSince": {
      "type": "object",
      "description": "Memories written after the synthesized summary was generated, so a stale summary is paired with what changed.",
      "properties": {
        "since": {
          "type": "string",
          "description": "When the synthesized summary was generated. Kept so a stale summary is always paired with what changed after it — memories newer than this moment are the ones listed here."
        },
        "note": {
          "type": "string"
        },
        "memories": {
          "type": "array"
        }
      },
      "additionalProperties": true
    },
    "integrations": {
      "type": "object"
    },
    "connections": {
      "type": "object"
    },
    "truncated": {
      "type": "boolean"
    },
    "truncated_boxes": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "description": "Composed profile context, or an authorization challenge when the user is not signed in.",
  "additionalProperties": true
}

Search or list permitted attributed profile memories/facts for the current user. Use this for personalized help, targeted retrieval, source-specific questions, or exact memory/fact lookup. For personalized help, pass a concrete query about the current task and relevant filters when known; no overview is needed first. Omit query or pass "*" only when the user asks to list saved memories, narrowing by the requested source, category or date when specified. For "what does <source> know about me?", pass query "*" plus source, e.g. "tempo" or "chatgpt". To search inside one category from configure_profile_read's table of contents, pass box with that box id, e.g. "work"; box narrows to the settled category facts and composes with query. For relative-date questions, resolve dates first and pass from/to; compact results may include snippets. Pass detail "full" when complete result text or inspectable metadata matters. Results from an import also carry imported_by_agent and import_id, which is what configure_profile_forget takes to retract that whole import.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Optional search query. Omit or use \"*\" to list bounded permitted attributed profile results, for example with a source filter."
    },
    "source": {
      "type": "string",
      "description": "Optional explicit source handle filter, such as \"tempo\", \"chatgpt\", or \"import:chatgpt\". Source-box ids from configure_profile_read's table of contents (\"agents/<name>\", \"imports/<provider>\") are also accepted and mean the same source. This is not a path or connector and there is no magic self value."
    },
    "box": {
      "type": "string",
      "description": "Optional category box id from configure_profile_read's table of contents, such as \"work\". Filters to the settled facts in that box and composes with query; unknown or empty boxes return empty results, never an error."
    },
    "from": {
      "type": "string",
      "description": "Optional inclusive start date filter in YYYY-MM-DD format for date-attributed results."
    },
    "to": {
      "type": "string",
      "description": "Optional inclusive end date filter in YYYY-MM-DD format for date-attributed results."
    },
    "limit": {
      "type": "number",
      "description": "Optional maximum result count. The backend enforces a default and hard cap."
    },
    "detail": {
      "type": "string",
      "enum": [
        "compact",
        "full"
      ],
      "description": "Optional result detail. Defaults to compact, which truncates long memory text. Full returns the complete text plus markers. Every result at either detail carries id, source, written_by, and saved_on (a YYYY-MM-DD date that matches the from/to filters)."
    }
  }
}

{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Matching attributed memories, each with id, text and source."
    },
    "visibleSources": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "guidance": {
      "type": "object",
      "description": "What to do next when results are thin: a status, a short explanation, and a suggested next action."
    }
  },
  "required": [
    "results"
  ],
  "additionalProperties": true
}

Save one explicit, durable fact the user stated about themselves so any Configure-connected agent the user allows can use it in future conversations. Use it when the user asks you to remember something or clearly signals a fact is for keeps (a stable preference stated for future use, an ongoing goal); a detail mentioned in passing is not a request to persist it — when intent is unclear, ask before saving. Save one clear fact per call. Its scope is one stated fact: bulk pasted material, message arrays, one-off task context, and anything the user did not actually say fall outside it — configure_profile_import handles bulk context and configure_profile_commit handles turn-level inference. To save memories inferred from a whole turn rather than a single stated fact, use configure_profile_commit instead. Your own work is not a fact about the user: what you built, shipped, debugged, or are tracking belongs on the shared project shelf, so file it with box "projects/<slug>" for the next agent to read back, or leave it out. Optionally file the fact into a box (a shelf within your namespace) with the box argument: reuse an existing box id from the profile table of contents when one fits, otherwise pass a short new lowercase name and it is created on the spot. Writes under your own server-resolved agent namespace (identity is resolved from the authenticated session rather than from arguments) and returns the stored memory id and source. Additive: it only saves what the user asked to keep. It never deletes or overwrites existing memories, and never emails, posts, or publishes anything on the user's behalf.

{
  "type": "object",
  "properties": {
    "fact": {
      "type": "string",
      "description": "Required. The single durable fact to store, phrased as a concise standalone statement about the user (for example \"Prefers vegetarian restaurants\"). One fact per call; do not batch multiple facts or paste transcript text."
    },
    "box": {
      "type": "string",
      "description": "Optional. The namespace box (shelf) to file this under. TWO KINDS. (1) A topic box, for facts about the user: \"work\", \"contacts\", \"health\". (2) \"projects/<slug>\", the shared handoff shelf, for notes written for OTHER AGENTS rather than about the user — status, handoffs, and what you did on a shared piece of work. Work called \"billing-migration\" goes to box \"projects/billing-migration\". Reuse an existing box id from the profile table of contents when one matches; otherwise a short new lowercase name creates that box instantly. Omitted files it under \"other\"."
    },
    "kind": {
      "type": "string",
      "enum": [
        "context",
        "claim",
        "status",
        "finding",
        "decision",
        "question",
        "blocker"
      ],
      "description": "What kind of note this is, for \"projects/<slug>\" notes. Set it whenever you are stuck or need something back from another agent: \"blocker\" (you cannot proceed) and \"question\" (you need an answer) are the two that get tracked as OPEN until another note resolves them. A note with no kind is never reported as outstanding, however urgent its text. This is not configure_profile_import's kind, which is a different vocabulary for how a dump is processed; and an unrecognized value here is never fatal, the note is saved unclassified and the result names the value that was ignored."
    },
    "reply_to": {
      "type": "string",
      "description": "Optional. Memory id (\"mem_...\") of a note in the SAME box this one answers. Ids appear on notes when you open a project box."
    },
    "resolves": {
      "type": "string",
      "description": "Optional. Memory id (\"mem_...\") of a question or blocker in the SAME box that this note closes, which is what stops it being reported as open."
    }
  },
  "required": [
    "fact"
  ]
}

{
  "type": "object",
  "properties": {
    "saved": {
      "type": "boolean"
    },
    "memory": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "Memory id, \"mem_\" prefixed. Pass to configure_profile_forget to delete it."
        },
        "text": {
          "type": "string"
        },
        "source": {
          "type": "string"
        },
        "written_by": {
          "type": "string"
        },
        "saved_on": {
          "type": "string",
          "description": "The date this memory was saved, YYYY-MM-DD. Matches the from/to filters on configure_profile_search."
        },
        "markers": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": true
    },
    "box": {
      "type": "string",
      "description": "Box the note was filed under."
    },
    "source": {
      "type": "string"
    },
    "distilled": {
      "type": "boolean"
    },
    "error": {
      "type": "string"
    }
  },
  "additionalProperties": true
}

Use this when the user asks to save several facts at once, or approves a list of facts you proposed. Saves each entry as a separate memory in the user's Configure profile, in one call. Send only facts the user asked to save or approved, each a short standalone statement about the user. If the user asks to review first, show the list and wait for their approval before calling. Use configure_profile_remember for a single fact. Accepts 1 to 25 facts per call, up to 1,000 characters each and 20,000 in total; send a longer approved list as several calls. It is not for passwords, keys, payment or health details, government identifiers, identity documents, sensitive personal attributes (race, religion, politics, sexuality, biometrics or genetics), or other people's personal data; the server's pattern checks are a backstop, not a complete filter, so these are left out before calling. Optional box files a fact under a category. Additive: it never changes or deletes existing memories. Returns a result for each entry and counts of saved, already_saved, refused and failed. Report those counts accurately, retry only failed entries, and never say the whole list was saved when some entries were refused or failed. Use configure_profile_import instead when the user supplies raw material rather than a list of facts: a note, a document, or an export from another assistant.

{
  "type": "object",
  "properties": {
    "facts": {
      "type": "array",
      "minItems": 1,
      "maxItems": 25,
      "description": "Short standalone facts the user asked to save or approved. At most 20,000 fact characters in total.",
      "items": {
        "type": "object",
        "properties": {
          "fact": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1000,
            "description": "One short standalone fact, preference, project or decision about the user."
          },
          "box": {
            "type": "string",
            "minLength": 1,
            "maxLength": 120,
            "description": "Optional category, for example \"work\" or \"preferences\". Reuse an existing category when one fits. Shared project categories are not supported by this tool."
          }
        },
        "required": [
          "fact"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "facts"
  ],
  "additionalProperties": false
}

{
  "type": "object",
  "properties": {
    "counts": {
      "type": "object",
      "properties": {
        "saved": {
          "type": "number"
        },
        "already_saved": {
          "type": "number"
        },
        "refused": {
          "type": "number"
        },
        "failed": {
          "type": "number"
        }
      },
      "required": [
        "saved",
        "already_saved",
        "refused",
        "failed"
      ],
      "additionalProperties": false
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "index": {
            "type": "number",
            "description": "1-based position in the supplied list."
          },
          "status": {
            "type": "string",
            "enum": [
              "saved",
              "already_saved",
              "refused",
              "failed"
            ]
          },
          "memory": {
            "type": "object",
            "properties": {
              "id": {
                "type": "string",
                "description": "Stored memory id. Pass to configure_profile_forget to remove it."
              },
              "text": {
                "type": "string"
              },
              "source": {
                "type": "string"
              },
              "saved_on": {
                "type": "string",
                "description": "Date saved, YYYY-MM-DD."
              }
            },
            "required": [
              "id",
              "text",
              "source"
            ],
            "additionalProperties": false
          },
          "box": {
            "type": "string"
          },
          "message": {
            "type": "string",
            "description": "Explanation when an entry was not saved. Refused content is not repeated."
          }
        },
        "required": [
          "index",
          "status"
        ],
        "additionalProperties": false
      }
    }
  },
  "required": [
    "counts",
    "results"
  ],
  "additionalProperties": true
}

Delete the user's memories that YOU saved or imported. WHICH to delete: if you hold an id, pass id ("mem_..."); if you do NOT have an id and the user names a topic, pass match with a word the memory contains (match: "nursing") and forget finds and deletes your matching memories itself, no search first. HOW: pass reason "user_request" whenever the user wants it gone for good or says never mention it again (this suppresses the content from re-saving and re-importing); use the default correction only for fixing your own mistake. A match previews first: it returns a count and the matching memories and deletes NOTHING until you call again with confirm: true, so review and confirm only what the user meant. import_id (from configure_profile_import) retracts one whole import; scope ("imports", "saved", "all") clears everything of yours at once. Pass exactly one selector. Reach is your own writes only: never another agent's memories, never an import the user ran themselves, never the profile's settled facts, and this deletes memories only, never the Configure account. An id outside your reach returns a clean not-found, not an error. Deletion is permanent for your copy. Returns the deleted memory id and which source it lived under.

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "One memory to delete, by the id returned when it was saved (format \"mem_...\", also shown on entries in your own source box). Use exactly one selector: id, import_id, or scope."
    },
    "date": {
      "type": "string",
      "description": "Optional. The memory's date (\"YYYY-MM-DD\") if known, from the saved path or entry; providing it makes the delete a direct lookup instead of a namespace scan."
    },
    "scope": {
      "type": "string",
      "enum": [
        "imports",
        "saved",
        "all"
      ],
      "description": "Delete everything of yours in one call, instead of one id at a time. \"imports\": every memory you brought in through configure_profile_import, including older imports that predate import ids. \"saved\": everything you saved with remember or commit. \"all\": both. Only your own writes are ever touched, so this can never reach another assistant's memories or the profile's settled facts."
    },
    "match": {
      "type": "string",
      "description": "Selector. Words a memory contains, e.g. \"nursing\" or \"coffee\". Finds YOUR OWN matching memories and deletes them, so you do not need a separate search to get ids first. A match WITHOUT confirm:true returns a count and preview and deletes nothing; call again with confirm:true to delete. Reach for this the moment a user says \"delete the X stuff\" and you do not already hold ids."
    },
    "confirm": {
      "type": "boolean",
      "description": "Only with match. Omit or false to preview (count + the memories that match, deletes nothing). Set true to delete the matched memories. Preview first unless the user was unambiguous."
    },
    "import_id": {
      "type": "string",
      "description": "Optional, and used instead of id. The import_id returned by configure_profile_import: retracts every memory that import created, in one call, instead of one delete per memory. Only entries from an import you performed are touched."
    },
    "reason": {
      "type": "string",
      "enum": [
        "correction",
        "user_request"
      ],
      "description": "Optional, default \"correction\". Use \"user_request\" ONLY when the user explicitly asked you to remove this and not bring it back (for example \"delete that\" or \"never call me that again\") — it additionally suppresses the same content from every source and blocks it from being re-saved or re-imported. Use \"correction\" (or omit) when you are fixing your own mistake or retracting something stale."
    }
  },
  "required": []
}

{
  "type": "object",
  "properties": {
    "deleted": {
      "type": "boolean",
      "description": "Whether anything was removed by this call. False on previews and no-matches."
    },
    "id": {
      "type": "string",
      "description": "The id of the deleted memory — the confirmation the caller acts on."
    },
    "deleted_count": {
      "type": "number"
    },
    "deleted_ids": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Ids of the memories a confirmed match deleted."
    },
    "match": {
      "type": "string",
      "description": "The match words this call used, echoed back."
    },
    "preview": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Memories a match would delete; nothing is deleted until confirm is true."
    },
    "matched": {
      "type": "number",
      "description": "For match-based forgets: how many memories matched."
    },
    "message": {
      "type": "string"
    },
    "error": {
      "type": "string",
      "description": "Present when the id was malformed or not found in your namespace."
    }
  },
  "required": [
    "deleted"
  ],
  "additionalProperties": true
}

Close out a Configure-profile-backed turn by submitting bounded turn evidence and, optionally, durable memories worth keeping. Error -32009 (commit_required) from any configure tool is resolved ONLY by this call: commit, then retry the blocked call — never configure_connect, which is for sign-in. Call it at turn end even when you learned nothing durable: reads and searches created obligations regardless, and an empty commit with a one-line summary clears them. The runtime usually calls this for you after a profile read; call it yourself only when your host requires manual write-back. Prefer configure_profile_remember for a single fact the user explicitly stated; use commit to clear the obligation created by a configure_profile_read or configure_profile_search and to save memories drawn from the whole turn. Evidence is minimal: at most the specific user statements that support each memory, plus toolResults — never conversation history; memories are durable user facts, preferences, or intentions rather than provenance or assistant replies. Returns the obligations it cleared and any memories written (id, source, marker). Additive: it only records what this turn learned. It never deletes or overwrites existing memories, and never emails, posts, or publishes anything on the user's behalf.

{
  "type": "object",
  "properties": {
    "memories": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Optional durable memory candidates to save, one clear fact per entry. Only include durable user facts, preferences, or intentions; do not summarize provenance, the conversation, or assistant replies."
    },
    "messages": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Optional minimal evidence to clear read-backed commit obligations: at most the one or two user statements that directly support each saved memory. Never send conversation history or any messages beyond those supporting statements."
    },
    "toolResults": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Optional bounded tool result evidence, each with toolName and content, used as evidence to clear read-backed commit obligations."
    },
    "read_id": {
      "type": "string",
      "description": "Optional read id returned by a prior configure_profile_read or configure_profile_search obligation; pass it to tie this commit to that specific read."
    }
  }
}

{
  "type": "object",
  "properties": {
    "committed": {
      "type": "boolean"
    },
    "obligations": {
      "type": "array",
      "description": "Read obligations this commit cleared."
    },
    "memories": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "id": {
            "type": "string",
            "description": "Memory id, \"mem_\" prefixed. Pass to configure_profile_forget to delete it."
          },
          "text": {
            "type": "string"
          },
          "source": {
            "type": "string"
          },
          "written_by": {
            "type": "string"
          },
          "saved_on": {
            "type": "string",
            "description": "The date this memory was saved, YYYY-MM-DD. Matches the from/to filters on configure_profile_search."
          },
          "markers": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "additionalProperties": true
      }
    },
    "error": {
      "type": "string"
    }
  },
  "additionalProperties": true
}

Share one Configure project without making a copy. Four modes with different stakes — action "list" only inspects (grants and open counts, changes nothing); every other mode changes access outside this conversation and needs the user's explicit go-ahead for that specific change. action "share" grants a named person (email or phone) read access, write only when the user explicitly grants it; "share" with mode "link" mints a public read-only link — confirm the user wants it public; "revoke" with grant_id removes one grant, and "revoke" WITHOUT grant_id unshares the whole project — confirm which of the two the user means before calling. Link tokens are shown once and never appear in grant listings.

{
  "type": "object",
  "properties": {
    "action": {
      "type": "string",
      "enum": [
        "share",
        "list",
        "revoke"
      ],
      "description": "The sharing action to perform."
    },
    "project": {
      "type": "string",
      "description": "Project slug, such as \"billing-migration\" or box id \"projects/billing-migration\"."
    },
    "with": {
      "type": "string",
      "description": "Email address or E.164 phone number for a private member share."
    },
    "mode": {
      "type": "string",
      "enum": [
        "link"
      ],
      "description": "Use \"link\" to mint a public read-only link. Links can never write."
    },
    "can_write": {
      "type": "boolean",
      "description": "For a member share, allow the member to append notes. Omit or false for read-only membership."
    },
    "expires_in_days": {
      "type": "number",
      "description": "Optional whole-number lifetime for this grant, from 1 to 3650 days."
    },
    "grant_id": {
      "type": "string",
      "description": "Grant id from a prior list result. Omit it with action \"revoke\" to unshare the whole project."
    }
  },
  "required": [
    "action",
    "project"
  ]
}

{
  "type": "object",
  "properties": {
    "project": {
      "type": "string",
      "description": "The canonical projects/<slug> box."
    },
    "share_url": {
      "type": "string",
      "description": "Public read-only URL. Present only in a successful link mint result."
    },
    "token": {
      "type": "string",
      "description": "Raw link token. Present exactly once in a successful link mint result and never in listings."
    },
    "resolved": {
      "type": "boolean",
      "description": "Whether a member contact resolved to a Configure identity."
    },
    "revoked": {
      "type": "boolean"
    },
    "grant_id": {
      "type": "string"
    },
    "share": {
      "type": "object"
    },
    "grant": {
      "type": "object"
    },
    "grants": {
      "type": "array",
      "items": {
        "type": "object"
      }
    }
  },
  "required": [
    "project"
  ],
  "additionalProperties": true
}

Import brings memories INTO the profile from outside — it never exports, lists, or shows what is already saved (use configure_profile_read or configure_profile_search for that, even when the user says "export" or "show me"). Two shapes go in here. A structured memory export, the ---SECTION:Name--- format with one dated entry per line that assistants produce when asked to export everything they know about the user, is split into individual profile facts and filed by category, which is how a first-time backfill from another assistant lands. Anything else is treated as one chunk of context: bulk-file it into your namespace when there is too much to save as a single fact — a long note, meeting notes, a multi-topic dump, or the current discussion when the user asks to save it. Configure distills it into a short context note (a stream, kept as-is in your namespace, not promoted to shared profile facts) and files it into a box automatically. Use configure_profile_remember instead for one clear fact the user stated; use configure_profile_commit to close out a turn after a profile read. Reach for import the moment the user provides material and says things like "keep all of this" or "import these notes", and when the user asks to save the current conversation ("save this whole conversation") — that explicit request is both the designation and the consent, so import is the right call, not a refusal. Send only what the user asked to keep, and never import anything on your own initiative. Optionally pass box to force the shelf: reuse an existing box id from the profile table of contents, or a short new lowercase name to create one; omit it to let Configure pick the box. Writes under your own agent namespace (resolved from the authenticated session, not arguments) and returns the chosen box and stored memory id. Additive: it only files context the user asked to keep. It never deletes or overwrites existing memories, and never emails, posts, or publishes anything on the user's behalf. Use configure_profile_remember_many instead when the user has already turned the material into a list of separate facts and approved it.

{
  "type": "object",
  "properties": {
    "text": {
      "type": "string",
      "description": "Required. The content the user explicitly asked to keep — a memory export from another assistant, material they provided, or the discussion they asked to save. Include only what the user asked to import, nothing beyond it; Configure distills it."
    },
    "kind": {
      "type": "string",
      "enum": [
        "memories",
        "context"
      ],
      "description": "Which of the two PROCESSING shapes this text is, because they are stored differently (a different argument from configure_profile_remember's kind, which classifies a single project note). \"memories\": the user's own durable facts in any format — an export from another assistant, a list of preferences, a compiled summary of what you know about them; each fact is split out and filed by category so it becomes part of the profile, and Configure reformats messy input so exact formatting does not matter. \"context\": source material to keep as-is — meeting notes, an article, a long document the user provided; condensed into one short note for reference. The test is whether each line should become a standing fact about the user (\"memories\") or the material itself is what matters (\"context\"). Omitted, Configure infers it from the text."
    },
    "box": {
      "type": "string",
      "description": "Optional, and only used for kind \"context\". The namespace box (shelf) to file the note under: reuse an existing box id from the profile table of contents, or a short new lowercase name to create one. Omit to let Configure choose. Ignored for kind \"memories\", which files each fact by category rather than into a namespace box."
    }
  },
  "required": [
    "text"
  ]
}

{
  "type": "object",
  "properties": {
    "saved": {
      "type": "boolean"
    },
    "memory": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "Memory id, \"mem_\" prefixed. Pass to configure_profile_forget to delete it."
        },
        "text": {
          "type": "string"
        },
        "source": {
          "type": "string"
        },
        "written_by": {
          "type": "string"
        },
        "saved_on": {
          "type": "string",
          "description": "The date this memory was saved, YYYY-MM-DD. Matches the from/to filters on configure_profile_search."
        },
        "markers": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "additionalProperties": true
    },
    "box": {
      "type": "string",
      "description": "Box the note was filed under."
    },
    "source": {
      "type": "string"
    },
    "distilled": {
      "type": "boolean"
    },
    "error": {
      "type": "string"
    }
  },
  "additionalProperties": true
}